六种核心安全机制-加密、密钥、签名与证书
安全要解决什么问题你都会的密码术安全机制之对称加密安全机制之非对称加密安全机制之密钥交换安全机制之消息摘要安全机制之电子签名安全机制之证书与PKI一、在典型的场景中，安全主要用于解决4类需求：1、保密（Security/Confidentiality）希望通信中的信息对外进行保密（不想任何第三方来窥探你的信息）例如：你是某个公司的高层领导，你有很多机密的文档。你可能放到了公司的保险箱或者家里的保险箱，只有你才有key（钥匙）才能打开看。2、鉴别/认证（Authentication）希望可以鉴别认证出与你通信的那个对端确实是所认为的那个对端。（例如跟你女朋友打电话，你怎么能确认和你打电话的那个人就是你女朋友）例如：你怎么能确认打电话的就是你朋友呢？不是仿冒的人在这里。通过你女朋友的声音可以鉴别出是女朋友本人。 例如：组织上安排重庆地下工作者与上海地下工作者接头在某个地点，并出示了相关接口口号，只有口号对头才能鉴别是要接头的人。例如：借钱的时候会写借条，写借条的技巧：用大小写，字体间隔非常小，防止篡改。3、完整性（Integrity）一旦某个信息产生了以后，你希望这个信息不能被谁来篡改；或者说它已经发生了篡改，你可以很方便的鉴别出它已经发生了篡改。4、不可否认性（non-repudiation）对于某一个信息，你可以很方便的确认这个信息是由谁产生的，并且一旦由某人产生了某个信息，将来在某一时刻他想否认都是不可以的。例如：犯人进行签字画押；皇帝传位需要写诏书和盖龙印。例如：电子文档签名。二、密码术：在日常场景中，其实你都在有意无意中利用密码术来完成特定的安全需求1、字母加密字母A用B代替，C用D代替，前面的一个字母用后面的一个字母替代。2、藏头诗诗里面藏了一些我要表达的含义。例如：毛氏今有才人出，晓文晓理难晓伊。冬去春来秋月夜，爱却江山爱美人。3、倒写文例如：把书信完整的倒过来写。4、任何规则都可以定义密码术5、为什么不自己发明和使用新的密码术呢？因为自己发明的密码术没有通过验证，没有黑客攻击过，很难考证它的安全强度。你有可能在密码术留下后门，将来用来盈利。6、算法和秘钥的分离算法公开，秘钥保密。算法公开的目的使用者的验证、专家的论证、黑客的尝试与破解。若干年后该密码术没有被黑客攻破或者专家破解，该密码术就会成为公开的算法。三、安全机制之对称加密1、典型的加密模型密钥：分为加密密钥和解密密钥。明文：没有进行加密，能够直接代表原文含义的信息。密文：经过加密处理之后，隐藏原文含义的信息。加密：将明文转换成密文的实施过程。解密：将密文转换成明文的实施过程。2、对称秘钥算法对称的含义（Symmetric）：加密端和解密端是用的同一个key置换加密，转置换加密和乘积密码（算法的模型）置换加密（顺序不变，原始的数据用其他数据替换，原始的字母用其他字母进行替换）例如：abcde ----> klmno转置换加密（原始数据的信息不变，是数据顺序打乱变化）例如：123456789 ----> 253698174乘积密码（置换密码和转置换密码的混合使用）例如：abcde ----> poklm ----> mlkpo3、DES（Data Encryption Standard）数据加密标准每取64bit （8byte）作为加密单元，经过19次的反复置换和转置换加密。秘钥其实是56bit。后面出现的3重DES，就是DES经过了三次转换。4、AES（Advanced Encryption Standard）高级加密标准运用了复杂的数学书法，内部构造还是沉积密码。它的输入是128bit，以128bit为单元加密。秘钥是可选的，可以以128bit长度加密单，也可以以192bit长度加密，也可以用256bit长度加密，比较灵活。四、安全机制之非对称加密非对称加密模型加密秘钥 K 称为公钥（public），解密秘钥 K ' 称为私钥（private）加密秘钥可以任何人知道，解密秘钥需要保密（解密者保管）。数学是科学基础，基础学科研究之物，虚虚实实，先虚后实。公开秘钥算法的最重要两大数学基础。1、建立在分解大数的困难度2、建立在以大素数为模来计算离散对数的困难度。RSA算法（非对称加密算法）建立在分解大数的困难度公钥/私钥长度 至少1024bit五、安全机制之密钥交换1、对称加密优缺点：高效（相对于非对称加密来说，传输速度快）秘钥交换问题（会话秘钥实时产生且周期性变化）不如RSA的加密安全程度高，但是当选择256bit的AES，仍然能胜任绝大多数的安全领域。2、非对称加密优缺点：安全性足够高没有秘钥交换的问题效率低，对于大数据加密很慢（加密算法复杂）3、其他秘钥交换方式：Diffie-Hellman 秘钥交换协议基于以大素数为模计算离散对数的困难度对方各自选定key，然后以一定算法交换（使得key不以明文传输）后传输给对方双方利用对方交换来的数据和自己选定的key做交换，获得一个一致的结果，作为会话秘钥六、安全机制之消息摘要1、HASH与散列函数的定义与特点HASH翻译成散列或者哈希HASH（散列）函数（算法）的定义是：变长的输入变换成定长的输出常见的HASH算法：MD5（128bit）、SHA1（160bit）HASH的特点：易变性：即便原始信息发生1bit的变化，HASH的输出将会有不可预知的巨大变化。不可逆：通过HASH结果构造出满足的输入信息是不可能的或者及其困难的。2、消息摘要与数字指纹人的指纹的特点：双胞胎的指纹不同；通过指纹猜不出它的主人。与Hash的对应关系：易变性、不可逆数字指纹由此而来消息摘要：摘要窥/定全体名字真多：HASH、哈希、散列、MD、消息摘要、数字指纹3、HASH的应用场景：放篡改基于易变性特性可保完整性示例：文件下载时的MD5、消息传送时尾部额外传MD4、HASH的应用场景：防损坏基于易变性特性可保完整性示例：CRC校验的作用和不足MD校验消息恶劣环境传输的完整性和未受损坏应用程序中对于核心文件/数据库读写的鲁棒性保护、防止掉电和Crash5、HASH的应用场景：认证基于不可逆向性可认证对端示例：HTTP的Basic和Diges认证（明文传输）PPP的PAP和CHAP认证（明文传输）手机登录密码和隐藏MMI的设计6、HMAC：Hash-based Message Authentication Code遇到的问题：直接尾部附带消息摘要的问题（篡改内容的同时篡改摘要）直接对密码做HASH传输的认证的问题（重放攻击）HMAC怎么解决的HMAC就是使用Key对原始消息变换后再近些HASH七、安全机制之电子签名1、签名要解决什么问题：签什么：签的内容的完整性包含谁在签：签名人的不可否认性2、公钥密码术的两面性：3、HASH+公钥密码术：成就电子签名八、安全机制之证书与PKI1、证书的作用：公钥的存储和交换公钥作为一个字段存储于数字证书中证书的交换和传输即可传输/交换公钥2、证书的作用：现代信任基石证书只是存储和交换公钥的吗？那我不可以把公钥直接作为一个文件来存储和交换吗？另外，我不可以篡改证书吗？我作为第三者，篡改小李发给小王的证书，把里面的公钥改成我的，以此来HACK别人发给小李的信息。利用签名来保护数字证书本身 人的信任关系：一个信任人的列表 数字时代的信任关系：一个受信任者的证书列表3、证书链和PKI人的信任链：孔子 -> 孔子的徒弟 -> 孔子的徒弟的徒弟数字时代的信任链：证书链证书签名的不同点：根证书的自签名，非根证书的父签名证书的限制：约束、用途、有效期PKI的概念4、基于证书的认证基于可信任证书的认证方式可被广泛的应用在现代安全领域，比如：wifi、https在https中，典型的Client对Server的认证和鉴别基于可信任列表
AES简介高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下： 下面简单介绍下各个部分的作用与意义：明文P没有经过加密的数据。密钥K用来加密明文的密码，[AES加密算法的详细介绍与实现]对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接[AES加密算法的详细介绍与实现]网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。AES加密函数设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输[AES加密算法的详细介绍与实现]，则加密函数E会输出密文C。密文C经加密函数处理后的数据AES解密函数设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输[AES加密算法的详细介绍与实现]，则解密函数会输出明文P。AES加密算法的详细介绍与实现[AES加密算法的详细介绍与实现]简单介绍下对称加密算法与非对称加密算法的区别。对称加密算法加密和解密用到的密钥是相同的，[AES加密算法的详细介绍与实现]种加密方式加密速度非常快，适合经常发送数据的场合。缺点是密钥的传输比较麻烦。非对称加密算法加密和解密用的密钥是不同的，[AES加密算法的详细介绍与实现]种加密方式是用数学上的难解问题构造的，通常加密解密的速度比较慢，适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal。实际中，一般是通过RSA加密AES的密钥，传输到接收方，接收方解密得到AES密钥，然后发送方和接收方用AES密钥来通信。本文下面AES原理的介绍参考自《现代密码学教程》，AES的实现[AES加密算法的详细介绍与实现]介绍完原理后开始。AES的基本结构AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。[AES加密算法的详细介绍与实现]AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：AES密钥长度（32位比特字)分组长度(32位比特字)加密轮数AES-1284410AES-1926412AES-2568414轮数[AES加密算法的详细介绍与实现]下面介绍，AES加密算法的详细介绍与实现实现的是AES-128，也就是密钥的长度为128位，加密轮数为10轮。 上面说到，AES的加密公式为C = E(K,P)，[AES加密算法的详细介绍与实现]加密函数E中，会执行一个轮函数，并且执行10次[AES加密算法的详细介绍与实现]个轮函数，[AES加密算法的详细介绍与实现]个轮函数的前9次执行的操作是一样的，只有第10次有所不同。也就是说，一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。AES的处理单位是字节，128位的输[AES加密算法的详细介绍与实现]明文分组P和输[AES加密算法的详细介绍与实现]密钥K都被分成16个字节，分别记为P = P0 P1 … P15 和 K = K0 K1 … K15。如，明文分组为P = abcdefghijklmnop,其中的字符a对应P0，p对应P15。一般地，明文分组用字节为单位的正方形矩阵AES加密算法的详细介绍与实现，称为状态矩阵。[AES加密算法的详细介绍与实现]算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如下[AES加密算法的详细介绍与实现]所示： 现[AES加密算法的详细介绍与实现]假设明文分组P为"abcdefghijklmnop"，则对应上面生成的状态矩阵[AES加密算法的详细介绍与实现]如下： 上[AES加密算法的详细介绍与实现]中，0x61为字符a的十六进制表示。可以看到，明文经过AES加密后，已经面目全非。类似地，128位密钥也是用字节为单位的矩阵表示，矩阵的每一列被称为1个32位比特字。通过密钥编排函数该密钥矩阵被扩展成一个44个字组成的序列W[0],W[1], … ,W[43],该序列的前4个元素W[0],W[1],W[2],W[3]是原始密钥，用于加密运算中的初始密钥加（下面介绍）;后面40个字分为10组，每组4个字（128比特）分别用于10轮加密运算中的轮密钥加，如下[AES加密算法的详细介绍与实现]所示： 上[AES加密算法的详细介绍与实现]中，设K = “abcdefghijklmnop”，则K0 = a, K15 = p, W[0] = K0 K1 K2 K3 = “abcd”。AES的整体结构如下[AES加密算法的详细介绍与实现]所示，其中的W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样，包括4个操作：字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，[AES加密算法的详细介绍与实现]第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。 上[AES加密算法的详细介绍与实现]也展示了AES解密过程，解密过程仍为10轮，每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的，因此，解密操作的一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似，最后一轮不执行逆列混合，[AES加密算法的详细介绍与实现]第1轮解密之前，要执行1次密钥加操作。下面分别介绍AES中一轮的4个操作阶段，[AES加密算法的详细介绍与实现]4分操作阶段使输[AES加密算法的详细介绍与实现]位得到充分的混淆。一、字节代换1.字节代换操作AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒。 AES的S盒：行/列[binary]状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的[AES加密算法的详细介绍与实现]如下： 2.字节代换逆操作逆字节代换也就是查逆S盒来变换，逆S盒如下：行/列[binary]二、行移位1.行移位操作行移位是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节，如下[AES加密算法的详细介绍与实现]所示： 2.行移位的逆变换行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如AES-128中，状态矩阵的第0行右移0字节，第1行右移1字节，第2行右移2字节，第3行右移3字节。三、列混合1.列混合操作列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下[AES加密算法的详细介绍与实现]的公式所示： 状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下[AES加密算法的详细介绍与实现]所示： 其中，矩阵元素的乘法和加法都是定义[AES加密算法的详细介绍与实现]基于GF(2^8)上的二元运算,并不是通常意义上的乘法和加法。AES加密算法的详细介绍与实现涉及到一些信息安全上的数学知识，不过不懂[AES加密算法的详细介绍与实现]些知识也行。其实[AES加密算法的详细介绍与实现]种二元运算的加法等价于两个字节的异或，乘法则复杂一点。对于一个8位的二进制数来说，使用域上的乘法乘以(00000010)等价于左移1位(低位补0)后，再根据情况同(00011011)进行异或运算，设S1 = (a7 a6 a5 a4 a3 a2 a1 a0)，刚0x02 * S1如下[AES加密算法的详细介绍与实现]所示： 也就是说，如果a7为1，则进行异或运算，否则不进行。 类似地，乘以(00000100)可以拆分成两次乘以(00000010)的运算： 乘以(0000 0011)可以拆分成先分别乘以(0000 0001)和(0000 0010)，再将两个乘积异或： [AES加密算法的详细介绍与实现AES加密算法的详细介绍与实现AES加密算法的详细介绍与实现AES加密算法的详细介绍与实现[AES加密算法的详细介绍与实现]](https://img-blog.csdnimg.cn/20210216120331436.png#pic_center)因此，我们只需要实现乘以2的函数，其他数值的乘法都可以通过组合来实现。 下面举个具体的例子,输[AES加密算法的详细介绍与实现]的状态矩阵如下：C9E5FD2B7AF2786E639C2667B0A782E5下面，进行列混合运算： 以第一列的运算为例： 其它列的计算就不列举了，列混合后生成的新状态矩阵如下：D4E7CD662802E5BBBEC6D6BF220FDFA52.列混合逆运算逆向列混合变换可由下[AES加密算法的详细介绍与实现]的矩阵乘法定义： 可以验证，逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。四、轮密钥加轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作，如下[AES加密算法的详细介绍与实现]所示。其中，密钥Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字，包含4个字节，他们的生成算法下面[AES加密算法的详细介绍与实现]下面介绍。轮密钥加过程可以看成是字逐位异或的结果，也可以看成字节级别或者位级别的操作。也就是说，可以看成S0 S1 S2 S3 组成的32位字与W[4i]的异或运算。 轮密钥加的逆运算同正向的轮密钥加运算完全一致，[AES加密算法的详细介绍与实现]是因为异或的逆操作是其自身。轮密钥加非常简单，但却能够影响S数组中的每一位。密钥扩展AES首先将初始密钥输[AES加密算法的详细介绍与实现]到一个4_4的状态矩阵中，如下[AES加密算法的详细介绍与实现]所示。 [AES加密算法的详细介绍与实现]个4_4矩阵的每一列的4个字节组成一个字，矩阵4列的4个字依次命名为W[0]、W[1]、W[2]和W[3]，它们构成一个以字为单位的数组W。例如，设密钥K为"abcdefghijklmnop",则K0 = ‘a’,K1 = ‘b’, K2 = ‘c’,K3 = ‘d’,W[0] = “abcd”。 接着，对W数组扩充40个新列，构成总共44列的扩展密钥数组。新列以如下的递归方式产生： 1.如果i不是4的倍数，那么第i列由如下等式确定： W[i]=W[i-4]⨁W[i-1] 2.如果i是4的倍数，那么第i列由如下等式确定： W[i]=W[i-4]⨁T(W[i-1]) 其中，T是一个有点复杂的函数。 函数T由3部分组成：字循环、字节代换和轮常量异或，[AES加密算法的详细介绍与实现]3部分的作用分别如下。 a.字循环：将1个字中的4个字节循环左移1个字节。即将输[AES加密算法的详细介绍与实现]字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。 b.字节代换：对字循环的结果使用S盒进行字节代换。 c.轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。 轮常量Rcon[j]是一个字，其值见下表。j12345Rcon[j]01 00 00 0002 00 00 0004 00 00 0008 00 00 0010 00 00 00j678910Rcon[j]20 00 00 0040 00 00 0080 00 00 001B 00 00 0036 00 00 00下面举个例子： 设初始的128位密钥为： 3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD 那么4个初始值为： W[0] = 3C A1 0B 21 W[1] = 57 F0 19 16 W[2] = 90 2E 13 80 W[3] = AC C1 07 BD 下面求扩展的第1轮的子密钥(W[4],W[5],W[6],W[7])。 由于4是4的倍数，所以： W[4] = W[0] ⨁ T(W[3]) T(W[3])的计算步骤如下：循环地将W[3]的元素移位：AC C1 07 BD变成C1 07 BD AC;将 C1 07 BD AC 作为S盒的输[AES加密算法的详细介绍与实现]，输出为78 C5 7A 91;将78 C5 7A 91与第一轮轮常量Rcon[1]进行异或运算，将得到79 C5 7A 91，因此，T(W[3])=79 C5 7A 91，故W\[4\] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 45 64 71 B0 其余的3个子密钥段的计算如下： W\[5\] = W\[1\] ⨁ W\[4\] = 57 F0 19 16 ⨁ 45 64 71 B0 = 12 94 68 A6 W\[6\] = W\[2\] ⨁ W\[5\] =90 2E 13 80 ⨁ 12 94 68 A6 = 82 BA 7B 26 W\[7\] = W\[3\] ⨁ W\[6\] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B 7C 9B 所以，第一轮的密钥为 45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B。 AES解密[AES加密算法的详细介绍与实现]文章开始的[AES加密算法的详细介绍与实现]中，有AES解密的流程[AES加密算法的详细介绍与实现]，可以对应那个流程[AES加密算法的详细介绍与实现]来进行解密。下面介绍的是另一种等价的解密模式，流程[AES加密算法的详细介绍与实现]如下[AES加密算法的详细介绍与实现]所示。[AES加密算法的详细介绍与实现]种等价的解密模式使得解密过程各个变换的使用顺序同加密过程的顺序一致，只是用逆变换取代原来的变换。 AES原理到AES加密算法的详细介绍与实现就结束了，下面主要为AES的实现，对以上原理中的每一个小节进行实现讲解，讲解的时候会AES加密算法的详细介绍与实现一些关键代码，完整的代码参见文章最后。文章最后提供两个完整的程序，一个能[AES加密算法的详细介绍与实现]linux下面编译运行，一个能[AES加密算法的详细介绍与实现]VC6.0下面编译通过。AES算法实现AES加密函数预览aes加密函数中，首先进行密钥扩展，然后把128位长度的字符串读进一个4*4的整数数组中，[AES加密算法的详细介绍与实现]个数组就是状态矩阵。例如，pArray[0][0] = S0,pArray[1][0] = S1, pArray[0][1] = S4。[AES加密算法的详细介绍与实现]个读取过程是通过 convertToIntArray()函数来实现的。每个轮操作的函数都对pArray进行修改，也就是对状态矩阵进行混淆。[AES加密算法的详细介绍与实现]执行完10轮加密后，会把pArray转换回字符串，再存[AES加密算法的详细介绍与实现]明文p的字符数组中，所以，[AES加密算法的详细介绍与实现]加密完后，明文p的字符串中的字符就是加密后的字符了。[AES加密算法的详细介绍与实现]个转换过程是通过convertArrayToStr()函数来实现的。/** * 参数 p: 明文的字符串数组。 * 参数 plen: 明文的长度。 * 参数 key: 密钥的字符串数组。 */ void aes(char *p, int plen, char *key){ int keylen = strlen(key); if(plen == 0 || plen % 16 != 0) { printf("明文字符长度必须为16的倍数！\n"); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 int pArray[4][4]; for(int k = 0; k < plen; k += 16) { convertToIntArray(p + k, pArray); addRoundKey(pArray, 0);//一开始的轮密钥加 for(int i = 1; i < 10; i++){//前9轮 subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 mixColumns(pArray);//列混合 addRoundKey(pArray, i); } //第10轮 subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 addRoundKey(pArray, 10); convertArrayToStr(pArray, p + k); } } 1.密钥扩展的实现[AES加密算法的详细介绍与实现]开始加密前，必须先获得第一轮加密用到的密钥，故先实现密钥扩展 下面是密钥扩展函数的实现，[AES加密算法的详细介绍与实现]个函数传[AES加密算法的详细介绍与实现]密钥key的字符串表示，然后从字符串中读取W[0]到W[3],函数getWordFromStr()用于实现此功能。读取后，就开始扩展密钥，当i是4的倍数的时候，就会调用T()函数来进行扩展，因为T函数的行为与加密的轮数有关，故要把加密的轮数 j 作为参数传进去。//密钥对应的扩展数组 static int w[44]; /** * 扩展密钥，结果是把w[44]中的每个元素初始化 */ static void extendKey(char *key) { for(int i = 0; i < 4; i++) w[i] = getWordFromStr(key + i * 4); for(int i = 4, j = 0; i < 44; i++) { if( i % 4 == 0) { w[i] = w[i - 4] ^ T(w[i - 1], j); j++;//下一轮 }else { w[i] = w[i - 4] ^ w[i - 1]; } } } 下面是T()函数的代码实现，T()函数中接收两个参数，参数num为上面传进的W[i - 1]，round为加密的轮数。首先用一个numArray储存从32位的W[i-1]中取得4个字节。如果W[i-1]为0x12ABCDEF,那么numArray[0] = 0x12,numArray[1] = 0xAB。函数splitIntToArray()用于从32位整数中读取[AES加密算法的详细介绍与实现]四个字节，之所以[AES加密算法的详细介绍与实现]样做是因为整数数组比较容易操作。然后调用leftLoop4int()函数把numArray数组中的4个元素循环左移1位。然后执行字节代换，通过getNumFromSBox()函数来获取S盒中相应的值来替换numArray中的值。接着通过mergeArrayToInt()函数把字节代换后的numArray合并回32位的整数，[AES加密算法的详细介绍与实现]进行轮常量异或后返回。/** * 常量轮值表 */ static const int Rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 }; /** * 密钥扩展中的T函数 */ static int T(int num, int round) { int numArray[4]; splitIntToArray(num, numArray); leftLoop4int(numArray, 1);//字循环 //字节代换 for(int i = 0; i < 4; i++) numArray[i] = getNumFromSBox(numArray[i]); int result = mergeArrayToInt(numArray); return result ^ Rcon[round]; } 2. 字节代换的实现字节代换的代码很简单，就是把状态矩阵中的每个元素传进getNumFromSBox()函数中，然后取得前面8位中的高4位作为行值，低4位作为列值，然后返回S[row][col]，AES加密算法的详细介绍与实现的S是储存S盒的数组。 /** * 根据索引，从S盒中获得元素 */ static int getNumFromSBox(int index) { int row = getLeft4Bit(index); int col = getRight4Bit(index); return S[row][col]; } /** * 字节代换 */ static void subBytes(int array[4][4]){ for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) array[i][j] = getNumFromSBox(array[i][j]); } 3.行移位的实现行移位的时候，首先把状态矩阵中第2，3，4行复制出来，然后对它们行进左移相应的位数，然后再复制回去状态矩阵array中。 /** * 将数组中的元素循环左移step位 */ static void leftLoop4int(int array[4], int step) { int temp[4]; for(int i = 0; i < 4; i++) temp[i] = array[i]; int index = step % 4 == 0 ? 0 : step % 4; for(int i = 0; i < 4; i++){ array[i] = temp[index]; index++; index = index % 4; } } /** * 行移位 */ static void shiftRows(int array[4][4]) { int rowTwo[4], rowThree[4], rowFour[4]; //复制状态矩阵的第2,3,4行 for(int i = 0; i < 4; i++) { rowTwo[i] = array[1][i]; rowThree[i] = array[2][i]; rowFour[i] = array[3][i]; } //循环左移相应的位数 leftLoop4int(rowTwo, 1); leftLoop4int(rowThree, 2); leftLoop4int(rowFour, 3); //把左移后的行复制回状态矩阵中 for(int i = 0; i < 4; i++) { array[1][i] = rowTwo[i]; array[2][i] = rowThree[i]; array[3][i] = rowFour[i]; } } 4.列混合的实现列混合函数中，先把状态矩阵初始状态复制一份到tempArray中，然后把tempArray与colM矩阵相乘，colM为存放要乘的常数矩阵的数组。其中的GFMul()函数定义了矩阵相乘时的乘法，加法则直接通过异或来实现。GFMul()通过调用乘以各个数对应的函数来实现乘法。例如，S1 * 2 刚通过调用GFMul2(S1)来实现。S1 * 3 刚通过GFMul3(S1)来实现。AES加密算法的详细介绍与实现[AES加密算法的详细介绍与实现]，主要实现GFMul2()函数就行了，其它的都可以通过GFMul2()的组合来实现。举个例子吧，为计算下面[AES加密算法的详细介绍与实现]条等式，需要像下面[AES加密算法的详细介绍与实现]样调用函数 s = GFMul3(0xC9) ^ 0x7A ^ 0x63 ^ GFMul2(0xB0)/** * 列混合要用到的矩阵 */ static const int colM[4][4] = { 2, 3, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 3, 1, 1, 2 }; static int GFMul2(int s) { int result = s << 1; int a7 = result & 0x00000100; if(a7 != 0) { result = result & 0x000000ff; result = result ^ 0x1b; } return result; } static int GFMul3(int s) { return GFMul2(s) ^ s; } /** * GF上的二元运算 */ static int GFMul(int n, int s) { int result; if(n == 1) result = s; else if(n == 2) result = GFMul2(s); else if(n == 3) result = GFMul3(s); else if(n == 0x9) result = GFMul9(s); else if(n == 0xb)//11 result = GFMul11(s); else if(n == 0xd)//13 result = GFMul13(s); else if(n == 0xe)//14 result = GFMul14(s); return result; } /** * 列混合 */ static void mixColumns(int array[4][4]) { int tempArray[4][4]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) tempArray[i][j] = array[i][j]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++){ array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j]) ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]); } } 5.轮密钥加的实现轮密钥加的实现很简单，就是根据传[AES加密算法的详细介绍与实现]的轮数来把状态矩阵与相应的W[i]异或。 /** * 轮密钥加 */ static void addRoundKey(int array[4][4], int round) { int warray[4]; for(int i = 0; i < 4; i++) { splitIntToArray(w[ round * 4 + i], warray); for(int j = 0; j < 4; j++) { array[j][i] = array[j][i] ^ warray[j]; } } } AES解密函数AES的解密函数和加密函数有点不同，可以参考上面的等价解密流程[AES加密算法的详细介绍与实现]来理解，解密函数中调用的是各轮操作的逆函数。逆函数AES加密算法的详细介绍与实现[AES加密算法的详细介绍与实现]就不详细讲解了，可以参考最后的完整代码。/** * 参数 c: 密文的字符串数组。 * 参数 clen: 密文的长度。 * 参数 key: 密钥的字符串数组。 */ void deAes(char *c, int clen, char *key) { int keylen = strlen(key); if(clen == 0 || clen % 16 != 0) { printf("密文字符长度必须为16的倍数！现[AES加密算法的详细介绍与实现]的长度为%d\n",clen); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 int cArray[4][4]; for(int k = 0; k < clen; k += 16) { convertToIntArray(c + k, cArray); addRoundKey(cArray, 10); int wArray[4][4]; for(int i = 9; i >= 1; i--) { deSubBytes(cArray); deShiftRows(cArray); deMixColumns(cArray); getArrayFrom4W(i, wArray); deMixColumns(wArray); addRoundTowArray(cArray, wArray); } deSubBytes(cArray); deShiftRows(cArray); addRoundKey(cArray, 0); convertArrayToStr(cArray, c + k); } } 完整的程序代码Linux版本aes.h#ifndef AES_H #define AES_H /** * 参数 p: 明文的字符串数组。 * 参数 plen: 明文的长度,长度必须为16的倍数。 * 参数 key: 密钥的字符串数组。 */ void aes(char *p, int plen, char *key); /** * 参数 c: 密文的字符串数组。 * 参数 clen: 密文的长度,长度必须为16的倍数。 * 参数 key: 密钥的字符串数组。 */ void deAes(char *c, int clen, char *key); #endif aes.c#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aes.h" /** * S盒 */ static const int S[16][16] = { 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, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; /** * 逆S盒 */ static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d }; /** * 获取整形数据的低8位的左4个位 */ static int getLeft4Bit(int num) { int left = num & 0x000000f0; return left >> 4; } /** * 获取整形数据的低8位的右4个位 */ static int getRight4Bit(int num) { return num & 0x0000000f; } /** * 根据索引，从S盒中获得元素 */ static int getNumFromSBox(int index) { int row = getLeft4Bit(index); int col = getRight4Bit(index); return S[row][col]; } /** * 把一个字符转变成整型 */ static int getIntFromChar(char c) { int result = (int) c; return result & 0x000000ff; } /** * 把16个字符转变成4X4的数组， * 该矩阵中字节的排列顺序为从上到下， * 从左到右依次排列。 */ static void convertToIntArray(char *str, int pa[4][4]) { int k = 0; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) { pa[j][i] = getIntFromChar(str[k]); k++; } } /** * 打印4X4的数组 */ static void printArray(int a[4][4]) { for(int i = 0; i < 4; i++){ for(int j = 0; j < 4; j++) printf("a[%d][%d] = 0x%x ", i, j, a[i][j]); printf("\n"); } printf("\n"); } /** * 打印字符串的ASSCI， * 以十六进制显示。 */ static void printASSCI(char *str, int len) { for(int i = 0; i < len; i++) printf("0x%x ", getIntFromChar(str[i])); printf("\n"); } /** * 把连续的4个字符合并成一个4字节的整型 */ static int getWordFromStr(char *str) { int one = getIntFromChar(str[0]); one = one << 24; int two = getIntFromChar(str[1]); two = two << 16; int three = getIntFromChar(str[2]); three = three << 8; int four = getIntFromChar(str[3]); return one | two | three | four; } /** * 把一个4字节的数的第一、二、三、四个字节取出， * [AES加密算法的详细介绍与实现]进一个4个元素的整型数组[AES加密算法的详细介绍与实现]面。 */ static void splitIntToArray(int num, int array[4]) { int one = num >> 24; array[0] = one & 0x000000ff; int two = num >> 16; array[1] = two & 0x000000ff; int three = num >> 8; array[2] = three & 0x000000ff; array[3] = num & 0x000000ff; } /** * 将数组中的元素循环左移step位 */ static void leftLoop4int(int array[4], int step) { int temp[4]; for(int i = 0; i < 4; i++) temp[i] = array[i]; int index = step % 4 == 0 ? 0 : step % 4; for(int i = 0; i < 4; i++){ array[i] = temp[index]; index++; index = index % 4; } } /** * 把数组中的第一、二、三和四元素分别作为 * 4字节整型的第一、二、三和四字节，合并成一个4字节整型 */ static int mergeArrayToInt(int array[4]) { int one = array[0] << 24; int two = array[1] << 16; int three = array[2] << 8; int four = array[3]; return one | two | three | four; } /** * 常量轮值表 */ static const int Rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 }; /** * 密钥扩展中的T函数 */ static int T(int num, int round) { int numArray[4]; splitIntToArray(num, numArray); leftLoop4int(numArray, 1);//字循环 //字节代换 for(int i = 0; i < 4; i++) numArray[i] = getNumFromSBox(numArray[i]); int result = mergeArrayToInt(numArray); return result ^ Rcon[round]; } //密钥对应的扩展数组 static int w[44]; /** * 扩展密钥，结果是把w[44]中的每个元素初始化 */ static void extendKey(char *key) { for(int i = 0; i < 4; i++) w[i] = getWordFromStr(key + i * 4); for(int i = 4, j = 0; i < 44; i++) { if( i % 4 == 0) { w[i] = w[i - 4] ^ T(w[i - 1], j); j++;//下一轮 }else { w[i] = w[i - 4] ^ w[i - 1]; } } } /** * 轮密钥加 */ static void addRoundKey(int array[4][4], int round) { int warray[4]; for(int i = 0; i < 4; i++) { splitIntToArray(w[ round * 4 + i], warray); for(int j = 0; j < 4; j++) { array[j][i] = array[j][i] ^ warray[j]; } } } /** * 字节代换 */ static void subBytes(int array[4][4]){ for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) array[i][j] = getNumFromSBox(array[i][j]); } /** * 行移位 */ static void shiftRows(int array[4][4]) { int rowTwo[4], rowThree[4], rowFour[4]; //复制状态矩阵的第2,3,4行 for(int i = 0; i < 4; i++) { rowTwo[i] = array[1][i]; rowThree[i] = array[2][i]; rowFour[i] = array[3][i]; } //循环左移相应的位数 leftLoop4int(rowTwo, 1); leftLoop4int(rowThree, 2); leftLoop4int(rowFour, 3); //把左移后的行复制回状态矩阵中 for(int i = 0; i < 4; i++) { array[1][i] = rowTwo[i]; array[2][i] = rowThree[i]; array[3][i] = rowFour[i]; } } /** * 列混合要用到的矩阵 */ static const int colM[4][4] = { 2, 3, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 3, 1, 1, 2 }; static int GFMul2(int s) { int result = s << 1; int a7 = result & 0x00000100; if(a7 != 0) { result = result & 0x000000ff; result = result ^ 0x1b; } return result; } static int GFMul3(int s) { return GFMul2(s) ^ s; } static int GFMul4(int s) { return GFMul2(GFMul2(s)); } static int GFMul8(int s) { return GFMul2(GFMul4(s)); } static int GFMul9(int s) { return GFMul8(s) ^ s; } static int GFMul11(int s) { return GFMul9(s) ^ GFMul2(s); } static int GFMul12(int s) { return GFMul8(s) ^ GFMul4(s); } static int GFMul13(int s) { return GFMul12(s) ^ s; } static int GFMul14(int s) { return GFMul12(s) ^ GFMul2(s); } /** * GF上的二元运算 */ static int GFMul(int n, int s) { int result; if(n == 1) result = s; else if(n == 2) result = GFMul2(s); else if(n == 3) result = GFMul3(s); else if(n == 0x9) result = GFMul9(s); else if(n == 0xb)//11 result = GFMul11(s); else if(n == 0xd)//13 result = GFMul13(s); else if(n == 0xe)//14 result = GFMul14(s); return result; } /** * 列混合 */ static void mixColumns(int array[4][4]) { int tempArray[4][4]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) tempArray[i][j] = array[i][j]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++){ array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j]) ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]); } } /** * 把4X4数组转回字符串 */ static void convertArrayToStr(int array[4][4], char *str) { for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) *str++ = (char)array[j][i]; } /** * 检查密钥长度 */ static int checkKeyLen(int len) { if(len == 16) return 1; else return 0; } /** * 参数 p: 明文的字符串数组。 * 参数 plen: 明文的长度。 * 参数 key: 密钥的字符串数组。 */ void aes(char *p, int plen, char *key){ int keylen = strlen(key); if(plen == 0 || plen % 16 != 0) { printf("明文字符长度必须为16的倍数！\n"); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 int pArray[4][4]; for(int k = 0; k < plen; k += 16) { convertToIntArray(p + k, pArray); addRoundKey(pArray, 0);//一开始的轮密钥加 for(int i = 1; i < 10; i++){//前9轮 subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 mixColumns(pArray);//列混合 addRoundKey(pArray, i); } //第10轮 subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 addRoundKey(pArray, 10); convertArrayToStr(pArray, p + k); } } /** * 根据索引从逆S盒中获取值 */ static int getNumFromS1Box(int index) { int row = getLeft4Bit(index); int col = getRight4Bit(index); return S2[row][col]; } /** * 逆字节变换 */ static void deSubBytes(int array[4][4]) { for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) array[i][j] = getNumFromS1Box(array[i][j]); } /** * 把4个元素的数组循环右移step位 */ static void rightLoop4int(int array[4], int step) { int temp[4]; for(int i = 0; i < 4; i++) temp[i] = array[i]; int index = step % 4 == 0 ? 0 : step % 4; index = 3 - index; for(int i = 3; i >= 0; i--) { array[i] = temp[index]; index--; index = index == -1 ? 3 : index; } } /** * 逆行移位 */ static void deShiftRows(int array[4][4]) { int rowTwo[4], rowThree[4], rowFour[4]; for(int i = 0; i < 4; i++) { rowTwo[i] = array[1][i]; rowThree[i] = array[2][i]; rowFour[i] = array[3][i]; } rightLoop4int(rowTwo, 1); rightLoop4int(rowThree, 2); rightLoop4int(rowFour, 3); for(int i = 0; i < 4; i++) { array[1][i] = rowTwo[i]; array[2][i] = rowThree[i]; array[3][i] = rowFour[i]; } } /** * 逆列混合用到的矩阵 */ static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9, 0x9, 0xe, 0xb, 0xd, 0xd, 0x9, 0xe, 0xb, 0xb, 0xd, 0x9, 0xe }; /** * 逆列混合 */ static void deMixColumns(int array[4][4]) { int tempArray[4][4]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) tempArray[i][j] = array[i][j]; for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++){ array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j]) ^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]); } } /** * 把两个4X4数组进行异或 */ static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) { for(int i = 0; i < 4; i++) for(int j = 0; j < 4; j++) aArray[i][j] = aArray[i][j] ^ bArray[i][j]; } /** * 从4个32位的密钥字中获得4X4数组， * 用于进行逆列混合 */ static void getArrayFrom4W(int i, int array[4][4]) { int index = i * 4; int colOne[4], colTwo[4], colThree[4], colFour[4]; splitIntToArray(w[index], colOne); splitIntToArray(w[index + 1], colTwo); splitIntToArray(w[index + 2], colThree); splitIntToArray(w[index + 3], colFour); for(int i = 0; i < 4; i++) { array[i][0] = colOne[i]; array[i][1] = colTwo[i]; array[i][2] = colThree[i]; array[i][3] = colFour[i]; } } /** * 参数 c: 密文的字符串数组。 * 参数 clen: 密文的长度。 * 参数 key: 密钥的字符串数组。 */ void deAes(char *c, int clen, char *key) { int keylen = strlen(key); if(clen == 0 || clen % 16 != 0) { printf("密文字符长度必须为16的倍数！现[AES加密算法的详细介绍与实现]的长度为%d\n",clen); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 int cArray[4][4]; for(int k = 0; k < clen; k += 16) { convertToIntArray(c + k, cArray); addRoundKey(cArray, 10); int wArray[4][4]; for(int i = 9; i >= 1; i--) { deSubBytes(cArray); deShiftRows(cArray); deMixColumns(cArray); getArrayFrom4W(i, wArray); deMixColumns(wArray); addRoundTowArray(cArray, wArray); } deSubBytes(cArray); deShiftRows(cArray); addRoundKey(cArray, 0); convertArrayToStr(cArray, c + k); } } main.c#include <stdio.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include "aes.h" #define MAXLEN 1024 void getString(char *str, int len){ int slen = read(0, str, len); for(int i = 0; i < slen; i++,str++){ if(*str == '\n'){ *str = '\0'; break; } } } void printASCCI(char *str, int len) { int c; for(int i = 0; i < len; i++) { c = (int)*str++; c = c & 0x000000ff; printf("0x%x ", c); } printf("\n"); } /** * 从标准输[AES加密算法的详细介绍与实现]中读取用户输[AES加密算法的详细介绍与实现]的字符串 */ void readPlainText(char *str, int *len) { int plen; while(1) { getString(str, MAXLEN); plen = strlen(str); if(plen != 0 && plen % 16 == 0) { printf("你输[AES加密算法的详细介绍与实现]的明文为：%s\n", str); break; }else{ printf("明文字符长度必须为16的倍数,现[AES加密算法的详细介绍与实现]的长度为%d\n", plen); } } *len = plen; } /** * 把字符串写进文件 */ void writeStrToFile(char *str, int len, char *fileName) { FILE *fp; fp = fopen(fileName, "wb"); for(int i = 0; i < len; i++) putc(str[i], fp); fclose(fp); } void aesStrToFile(char *key) { char p[MAXLEN]; int plen; printf("请输[AES加密算法的详细介绍与实现]你的明文，明文字符长度必须为16的倍数\n"); readPlainText(p,&plen); printf("进行AES加密..................\n"); aes(p, plen, key);//AES加密 printf("加密完后的明文的ASCCI为：\n"); printASCCI(p, plen); char fileName[64]; printf("请输[AES加密算法的详细介绍与实现]你想要写进的文件名，比如'test.txt':\n"); if(scanf("%s", fileName) == 1) { writeStrToFile(p, plen, fileName); printf("已经将密文写进%s中了,可以[AES加密算法的详细介绍与实现]运行该程序的当前目录中找到它。\n", fileName); } } /** * 从文件中读取字符串 */ int readStrFromFile(char *fileName, char *str) { FILE *fp = fopen(fileName, "rb"); if(fp == NULL) { printf("打开文件出错，请确认文件存[AES加密算法的详细介绍与实现]当前目录下！\n"); exit(0); } int i; for(i = 0; i < MAXLEN && (str[i] = getc(fp)) != EOF; i++); if(i >= MAXLEN) { printf("解密文件过大！\n"); exit(0); } str[i] = '\0'; fclose(fp); return i; } void deAesFile(char *key) { char fileName[64]; char c[MAXLEN];//密文字符串 printf("请输[AES加密算法的详细介绍与实现]要解密的文件名，该文件必须和本程序[AES加密算法的详细介绍与实现]同一个目录\n"); if(scanf("%s", fileName) == 1) { int clen = readStrFromFile(fileName, c); printf("开始解密.........\n"); deAes(c, clen, key); printf("解密后的明文ASCII为：\n"); printASCCI(c, clen); printf("明文为：%s\n", c); writeStrToFile(c,clen,fileName); printf("现[AES加密算法的详细介绍与实现]可以打开%s来查看解密后的密文了！\n",fileName); } } void aesFile(char *key) { char fileName[64]; char fileP[MAXLEN]; printf("请输[AES加密算法的详细介绍与实现]要加密的文件名，该文件必须和本程序[AES加密算法的详细介绍与实现]同一个目录\n"); if(scanf("%s", fileName) == 1) { readStrFromFile(fileName, fileP); int plen = strlen(fileP); printf("开始加密.........\n"); printf("加密前文件中字符的ASCII为：\n"); printASCCI(fileP, plen); aes(fileP, plen, key);//开始加密 printf("加密后的密文ASCII为：\n"); printASCCI(fileP, plen); writeStrToFile(fileP,plen,fileName); printf("已经将加密后的密文写进%s中了\n",fileName); } } int main(int argc, char const *argv[]) { char key[17]; printf("请输[AES加密算法的详细介绍与实现]16个字符的密钥：\n"); int klen; while(1){ getString(key,17); klen = strlen(key); if(klen != 16){ printf("请输[AES加密算法的详细介绍与实现]16个字符的密钥,当前密钥的长度为%d\n",klen); }else{ printf("你输[AES加密算法的详细介绍与实现]的密钥为：%s\n",key); break; } } printf("输[AES加密算法的详细介绍与实现]'s'表示要加密输[AES加密算法的详细介绍与实现]的字符串,并将加密后的内容写[AES加密算法的详细介绍与实现]到文件\n"); printf("请输[AES加密算法的详细介绍与实现]要功能选项并按回车，输[AES加密算法的详细介绍与实现]'f'表示要加密文件\n"); printf("输[AES加密算法的详细介绍与实现]'p'表示要解密文件\n"); char c; if(scanf("%s",&c) == 1) { if(c == 's') aesStrToFile(key);//用AES加密字符串，并将字符串写进文件中 else if(c == 'p') deAesFile(key);//把文件中的密文解密，并写回文件中 else if(c == 'f')//用AES加密文件 aesFile(key); } return 0; } 通过下面的gcc命令来编译运行：gcc -o aes aes.c main.c VC6.0版本由于VC6.0的编译器比较坑，要先声明，后使用变量，故要对代码进行相应的修改。aes.h#ifndef MY_AES_H #define MY_AES_H /** * 参数 p: 明文的字符串数组。 * 参数 plen: 明文的长度,长度必须为16的倍数。 * 参数 key: 密钥的字符串数组。 */ void aes(char *p, int plen, char *key); /** * 参数 c: 密文的字符串数组。 * 参数 clen: 密文的长度,长度必须为16的倍数。 * 参数 key: 密钥的字符串数组。 */ void deAes(char *c, int clen, char *key); #endif aes.cpp#include <stdio.h> #include <stdlib.h> #include <string.h> #include "aes.h" /** * S盒 */ static const int S[16][16] = { 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, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; /** * 逆S盒 */ static const int S2[16][16] = { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d }; /** * 获取整形数据的低8位的左4个位 */ static int getLeft4Bit(int num) { int left = num & 0x000000f0; return left >> 4; } /** * 获取整形数据的低8位的右4个位 */ static int getRight4Bit(int num) { return num & 0x0000000f; } /** * 根据索引，从S盒中获得元素 */ static int getNumFromSBox(int index) { int row = getLeft4Bit(index); int col = getRight4Bit(index); return S[row][col]; } /** * 把一个字符转变成整型 */ static int getIntFromChar(char c) { int result = (int) c; return result & 0x000000ff; } /** * 把16个字符转变成4X4的数组， * 该矩阵中字节的排列顺序为从上到下， * 从左到右依次排列。 */ static void convertToIntArray(char *str, int pa[4][4]) { int k = 0; int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) { pa[j][i] = getIntFromChar(str[k]); k++; } } /** * 打印4X4的数组 */ static void printArray(int a[4][4]) { int i,j; for(i = 0; i < 4; i++){ for(j = 0; j < 4; j++) printf("a[%d][%d] = 0x%x ", i, j, a[i][j]); printf("\n"); } printf("\n"); } /** * 打印字符串的ASSCI， * 以十六进制显示。 */ static void printASSCI(char *str, int len) { int i; for(i = 0; i < len; i++) printf("0x%x ", getIntFromChar(str[i])); printf("\n"); } /** * 把连续的4个字符合并成一个4字节的整型 */ static int getWordFromStr(char *str) { int one, two, three, four; one = getIntFromChar(str[0]); one = one << 24; two = getIntFromChar(str[1]); two = two << 16; three = getIntFromChar(str[2]); three = three << 8; four = getIntFromChar(str[3]); return one | two | three | four; } /** * 把一个4字节的数的第一、二、三、四个字节取出， * [AES加密算法的详细介绍与实现]进一个4个元素的整型数组[AES加密算法的详细介绍与实现]面。 */ static void splitIntToArray(int num, int array[4]) { int one, two, three; one = num >> 24; array[0] = one & 0x000000ff; two = num >> 16; array[1] = two & 0x000000ff; three = num >> 8; array[2] = three & 0x000000ff; array[3] = num & 0x000000ff; } /** * 将数组中的元素循环左移step位 */ static void leftLoop4int(int array[4], int step) { int temp[4]; int i; int index; for(i = 0; i < 4; i++) temp[i] = array[i]; index = step % 4 == 0 ? 0 : step % 4; for(i = 0; i < 4; i++){ array[i] = temp[index]; index++; index = index % 4; } } /** * 把数组中的第一、二、三和四元素分别作为 * 4字节整型的第一、二、三和四字节，合并成一个4字节整型 */ static int mergeArrayToInt(int array[4]) { int one = array[0] << 24; int two = array[1] << 16; int three = array[2] << 8; int four = array[3]; return one | two | three | four; } /** * 常量轮值表 */ static const int Rcon[10] = { 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000 }; /** * 密钥扩展中的T函数 */ static int T(int num, int round) { int numArray[4]; int i; int result; splitIntToArray(num, numArray); leftLoop4int(numArray, 1);//字循环 //字节代换 for(i = 0; i < 4; i++) numArray[i] = getNumFromSBox(numArray[i]); result = mergeArrayToInt(numArray); return result ^ Rcon[round]; } //密钥对应的扩展数组 static int w[44]; /** * 打印W数组 */ static void printW() { int i, j; for(i = 0, j = 1; i < 44; i++,j++){ printf("w[%d] = 0x%x ", i, w[i]); if(j % 4 == 0) printf("\n"); } printf("\n"); } /** * 扩展密钥，结果是把w[44]中的每个元素初始化 */ static void extendKey(char *key) { int i,j; for(i = 0; i < 4; i++) w[i] = getWordFromStr(key + i * 4); for(i = 4, j = 0; i < 44; i++) { if( i % 4 == 0) { w[i] = w[i - 4] ^ T(w[i - 1], j); j++;//下一轮 }else { w[i] = w[i - 4] ^ w[i - 1]; } } } /** * 轮密钥加 */ static void addRoundKey(int array[4][4], int round) { int warray[4]; int i,j; for(i = 0; i < 4; i++) { splitIntToArray(w[ round * 4 + i], warray); for(j = 0; j < 4; j++) { array[j][i] = array[j][i] ^ warray[j]; } } } /** * 字节代换 */ static void subBytes(int array[4][4]){ int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) array[i][j] = getNumFromSBox(array[i][j]); } /** * 行移位 */ static void shiftRows(int array[4][4]) { int rowTwo[4], rowThree[4], rowFour[4]; int i; for(i = 0; i < 4; i++) { rowTwo[i] = array[1][i]; rowThree[i] = array[2][i]; rowFour[i] = array[3][i]; } leftLoop4int(rowTwo, 1); leftLoop4int(rowThree, 2); leftLoop4int(rowFour, 3); for(i = 0; i < 4; i++) { array[1][i] = rowTwo[i]; array[2][i] = rowThree[i]; array[3][i] = rowFour[i]; } } /** * 列混合要用到的矩阵 */ static const int colM[4][4] = { 2, 3, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 3, 1, 1, 2 }; static int GFMul2(int s) { int result = s << 1; int a7 = result & 0x00000100; if(a7 != 0) { result = result & 0x000000ff; result = result ^ 0x1b; } return result; } static int GFMul3(int s) { return GFMul2(s) ^ s; } static int GFMul4(int s) { return GFMul2(GFMul2(s)); } static int GFMul8(int s) { return GFMul2(GFMul4(s)); } static int GFMul9(int s) { return GFMul8(s) ^ s; } static int GFMul11(int s) { return GFMul9(s) ^ GFMul2(s); } static int GFMul12(int s) { return GFMul8(s) ^ GFMul4(s); } static int GFMul13(int s) { return GFMul12(s) ^ s; } static int GFMul14(int s) { return GFMul12(s) ^ GFMul2(s); } /** * GF上的二元运算 */ static int GFMul(int n, int s) { int result; if(n == 1) result = s; else if(n == 2) result = GFMul2(s); else if(n == 3) result = GFMul3(s); else if(n == 0x9) result = GFMul9(s); else if(n == 0xb)//11 result = GFMul11(s); else if(n == 0xd)//13 result = GFMul13(s); else if(n == 0xe)//14 result = GFMul14(s); return result; } /** * 列混合 */ static void mixColumns(int array[4][4]) { int tempArray[4][4]; int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) tempArray[i][j] = array[i][j]; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++){ array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j]) ^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]); } } /** * 把4X4数组转回字符串 */ static void convertArrayToStr(int array[4][4], char *str) { int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) *str++ = (char)array[j][i]; } /** * 检查密钥长度 */ static int checkKeyLen(int len) { if(len == 16) return 1; else return 0; } /** * 参数 p: 明文的字符串数组。 * 参数 plen: 明文的长度。 * 参数 key: 密钥的字符串数组。 */ void aes(char *p, int plen, char *key){ int keylen = strlen(key); int pArray[4][4]; int k,i; if(plen == 0 || plen % 16 != 0) { printf("明文字符长度必须为16的倍数！\n"); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 for(k = 0; k < plen; k += 16) { convertToIntArray(p + k, pArray); addRoundKey(pArray, 0);//一开始的轮密钥加 for(i = 1; i < 10; i++){ subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 mixColumns(pArray);//列混合 addRoundKey(pArray, i); } subBytes(pArray);//字节代换 shiftRows(pArray);//行移位 addRoundKey(pArray, 10); convertArrayToStr(pArray, p + k); } } /** * 根据索引从逆S盒中获取值 */ static int getNumFromS1Box(int index) { int row = getLeft4Bit(index); int col = getRight4Bit(index); return S2[row][col]; } /** * 逆字节变换 */ static void deSubBytes(int array[4][4]) { int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) array[i][j] = getNumFromS1Box(array[i][j]); } /** * 把4个元素的数组循环右移step位 */ static void rightLoop4int(int array[4], int step) { int temp[4]; int i; int index; for(i = 0; i < 4; i++) temp[i] = array[i]; index = step % 4 == 0 ? 0 : step % 4; index = 3 - index; for(i = 3; i >= 0; i--) { array[i] = temp[index]; index--; index = index == -1 ? 3 : index; } } /** * 逆行移位 */ static void deShiftRows(int array[4][4]) { int rowTwo[4], rowThree[4], rowFour[4]; int i; for(i = 0; i < 4; i++) { rowTwo[i] = array[1][i]; rowThree[i] = array[2][i]; rowFour[i] = array[3][i]; } rightLoop4int(rowTwo, 1); rightLoop4int(rowThree, 2); rightLoop4int(rowFour, 3); for(i = 0; i < 4; i++) { array[1][i] = rowTwo[i]; array[2][i] = rowThree[i]; array[3][i] = rowFour[i]; } } /** * 逆列混合用到的矩阵 */ static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9, 0x9, 0xe, 0xb, 0xd, 0xd, 0x9, 0xe, 0xb, 0xb, 0xd, 0x9, 0xe }; /** * 逆列混合 */ static void deMixColumns(int array[4][4]) { int tempArray[4][4]; int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) tempArray[i][j] = array[i][j]; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++){ array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j]) ^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]); } } /** * 把两个4X4数组进行异或 */ static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) { int i,j; for(i = 0; i < 4; i++) for(j = 0; j < 4; j++) aArray[i][j] = aArray[i][j] ^ bArray[i][j]; } /** * 从4个32位的密钥字中获得4X4数组， * 用于进行逆列混合 */ static void getArrayFrom4W(int i, int array[4][4]) { int index,j; int colOne[4], colTwo[4], colThree[4], colFour[4]; index = i * 4; splitIntToArray(w[index], colOne); splitIntToArray(w[index + 1], colTwo); splitIntToArray(w[index + 2], colThree); splitIntToArray(w[index + 3], colFour); for(j = 0; j < 4; j++) { array[j][0] = colOne[j]; array[j][1] = colTwo[j]; array[j][2] = colThree[j]; array[j][3] = colFour[j]; } } /** * 参数 c: 密文的字符串数组。 * 参数 clen: 密文的长度。 * 参数 key: 密钥的字符串数组。 */ void deAes(char *c, int clen, char *key) { int cArray[4][4]; int keylen,k; keylen = strlen(key); if(clen == 0 || clen % 16 != 0) { printf("密文字符长度必须为16的倍数！现[AES加密算法的详细介绍与实现]的长度为%d\n",clen); exit(0); } if(!checkKeyLen(keylen)) { printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen); exit(0); } extendKey(key);//扩展密钥 for(k = 0; k < clen; k += 16) { int i; int wArray[4][4]; convertToIntArray(c + k, cArray); addRoundKey(cArray, 10); for(i = 9; i >= 1; i--) { deSubBytes(cArray); deShiftRows(cArray); deMixColumns(cArray); getArrayFrom4W(i, wArray); deMixColumns(wArray); addRoundTowArray(cArray, wArray); } deSubBytes(cArray); deShiftRows(cArray); addRoundKey(cArray, 0); convertArrayToStr(cArray, c + k); } } 有不少初学者可能[AES加密算法的详细介绍与实现]使用AES实现的VC版本时，会出现没main函数的问题。其实直接导[AES加密算法的详细介绍与实现]VC编译是不行的，AES加密算法的详细介绍与实现给出的只是头文件 aes.h 和实现的 aes.cpp 文件，需要通过include来包含使用，假设main函数所[AES加密算法的详细介绍与实现]的文件 main.cpp，并且与 aes.h 、 aes.cpp 文件[AES加密算法的详细介绍与实现]同一目录下，则需要像下面[AES加密算法的详细介绍与实现]样使用: #include "aes.h" // 其它头文件 int main(int argc, char const *argv[]) { // 加密, 其中plain是明文字符数组， len是长度， key是密钥 aes(plain, len, key); //解密，其中ciphertext是密文字符数组， len是长度， key是密钥 deAes(ciphertext, len, key); }