RGB颜色与16进制颜色的换算方法
我的图书馆
RGB颜色与16进制颜色的换算方法
网页中表示颜色的常见方法有:1.Color Name(颜色名称) 用颜色名称来指定颜色，这种方法简洁直观，一看就知道是什么颜色，但最大的缺点是颜色的名称太少，不能有效的表示一些较丰富的颜色2.RGB(RGB记法)3.HEX(十六进制记法)RGB记法和十六进制记法都能很好的表示出一些较为丰富的颜色，但是我们用到16进制的比较多，语法为#RRGGBB，下面说下我刚研究出来的转换方法:我们都知道RGB记法rgb(255,255,255)=十六进制记法#FFFFFF，都表示白色RGB记法rgb(0,0,0)=十六进制记法#000000，都表示黑色那么RGB记法rgb(100,150,245)=十六进制记法#??????RGB的取值都是0~255，HEX的取值为ABCDEF这16个字符，下面看看RGB-HEX对照表
通过这张表我们可以发现rgb中的0对应HEX的00，1对应01……9对应0910则对应0A，11对应0B……15对应0F16对应了10这里总共17对,除去一对特殊的0对应00,剩下的16对大家都应该发现规律了吧，rgb的数值是16乘以HEX的第一位加上HEX的第二位，数字10一下的RGB和HEX都是相同的，不同的是HEX是两位数,在前面补0就可以了，10对应A，11对应B，12对应C，13对应D，14对应E，15对应F，下面通过例子来说明RGB到HEX的换算办法例1:rgb(11,111,222)=#??????11÷16=0余11 & 11对应B &前面补0 &那么HEX的数据为0B111÷16=6余15 &15对应F & 那么HEX的数据为6F222÷16=13余14 &13对应D &14对应E & 那么HEX的数据为DE合起来HEX的数据就为#0B6FDE&例2:rgb(0,16,255)=#??????0直接对应0016÷16=1余0 &则HEX的数据为10255÷16=15余15 &15对应F &则HEX的数据为FF合起来HEX的数据就为#0010FFHEX转换RGB不用说了吧,倒过来就行了本文首发地址:&转载请注明出处
喜欢该文的人也喜欢18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 的翻译是：和 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
中文翻译英文意思，翻译英语
请在下面的文本框内输入文字，然后点击开始翻译按钮进行翻译，如果您看不到结果，请重新翻译！
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
选择语言：从
罗马尼亚语
罗马尼亚语
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
和 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
正在翻译，请等待...
并且18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
相关内容&a掌握photoshop、coreldraw、CAD等软件的操作 Grasps software and so on photoshop, coreldraw, CAD operations & a提供技术支持，技术培训，技术咨询，技术测试， 承接其母公司和关联企业的服务外包业务 正在翻译，请等待... & aif you think about each picture for 10 to 20 seconds,you'll find out its meaning. 如果您考虑每张图片10到20秒，您将发现它的意思。 & agaggia gaggia & aWhat the fuck have you done 什么交往有您做 & a曾经有个朋友 Once had a friend & aPropio 拥有 & a我可以去你学校找你吗 I may go to your school to look for you & aThe full stack trace of the root cause is available in the Tomcat logs 起因的充分的栈检索是可利用的在雄猫日志 & a美国梦是说美国人如何实现理想和自由的。 The American dream is said how the American does realize ideal and free. & aI don't get up 正在翻译，请等待...
& a我有多多的问题啊 I have the very much question & a上次生产4号产品，我们多备了布料，但由于产品不合格率太高，导致交货不够数量。 Previous time produces 4 products, we have prepared the cotton material, but because the product fraction defective too is high, causes the delivery insufficient quantity. & a快印 Quick India & ahe finally refused to give up his plan of travelling the world 他最后拒绝放弃他的计划旅行世界 & a减底渣油线基本信息 Reduces the bottom residual oil line basic information & aDrynk the candy Drynk糖果 & awhat does the class do on Lune 25th? 类做什么在Lune第25 ？ & awe need friends to share happiness and sorrow,and that it is important to have someone to care abou we need friends to share happiness and sorrow, and that it is important to have someone to care abou & aDon't be a woman that needs a man.Be a woman that a man need.. Don't be a woman that needs a man. Be a woman that a man need. & a衣着上的变化 On attire change & aOh, ask me that again tomorrow
& a有许多新工作要做。 Some many new work must do. & a半经验的 正在翻译，请等待...
& aI do not know whether appropriate asking you this question 我不知道是否适当问您这个问题 & aGrain, area ratio 正在翻译，请等待...
& aOne man's fault is another man's lesson. 一个人的缺点是另一个人的教训。 & aI am a
Woman Man 我是一个妇女人 & aand
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 并且18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 &扫一扫手机看资讯 发爆料
重归美好生活
搜店铺 找优惠做安徽人的掌上生活指南
2017合肥市少儿诵读大赛海选全面展开 6月3日海选结果公布
雅言传承文明，经典浸润人生。为推进全民阅读，弘扬传统文化，传承中华文明，由共青团合肥市委员会、合肥市妇联、合肥市文广新局主办，十月少年文学杂志、万家热线、万家社区、合肥市图书馆承办的&阅读合肥 书香万家&2017合肥市少儿诵读大赛海选正如火如荼开展。
诵读大赛合肥阳光中学海选现场
2017合肥市少儿诵读大赛首场海选在庐阳举行之后，引起了社会各界广泛关注，在家长和学生们中反响强烈。很多家长都把让孩子参加诵读大赛当作是一次锻炼、学习的好机会。6月3日、4日两天，2017合肥市少儿诵读大赛全城海选全面展开，5场海选同步进行，参赛人群涵盖包河、蜀山、滨湖等多个区域。
诵读大赛合肥屯溪路海选现场
今天，三个场次的海选火热进行，其中包括上午的阳光中学海选、下午的屯溪路小学海选及师范附小四小海选，共有50多个团队、260多个人参加了海选比赛。海选根据分数高低，每场次分别评出了特等奖、一、二、三等奖及优秀奖，特等奖直接获得决赛通行证。
诵读大赛海选一晋级决赛团队合影
目前，2017合肥市少儿诵读大赛 6月3日海选已经圆满结束，现将各场比赛成绩予以公布。
诵读大赛6月3日上午场海选成绩（团体）：
范凌菲 贺瑞多 陈旭 任昊 高菲 葛慧如
曹锐 杜萌 张冰琪 王梦醒 秦慧琳 燕志
江士媛（老师）
常珂晴 李浩楠 王伟民 韦庆雨 孙文梦 徐博胜 薛鹏辉 胡文婧
罗乐雯 王祯阳 叶欣怡 王嘉怿
合肥市阳光中学
王嘉诚 窦欣阳 程姝涵 马兴坤 王思语 孙妍 朱郑熙
汪雪 刘圣婷 张雪晴 卫欣宇
邓简佳 秦晨 孙嘉怡 陈若汐
杨可欣 车路瑶 开宇翔 开馨晓楠
陆瑞娜（老师）徐涵 殷之璇 罗彩虹 戴元羲 李梦馨 杨雨
汪子楊 孟宇轩 毕淑雯 屈浩冉 余丽 张蓝鸥
李郭轩 何俊晖 卓敏行 叶成诚 黄梓荀
陈梦娜 钱怡煊 周熙雯 王芷晨 俞鸿杰
&范梦茹（老师）陈曦涛 陈锦鹏 刘睿晨 费锦顺 江博
詹元媛（家长）张裕树 沈芯岳 张明慧 张振轩 胡敬茜
赵杰（家长）
诵读大赛6月3日上午场海选成绩（个人）：
诵读大赛6月3日下午场海选成绩（团体）：
王语涵 关子玲 王熙悦 高子瑞 李熹来 邱一诺 潘玥欣然 王心瑜
陈思雨 李苏皖 陈云熙 张奕婷
胡桐飞 甘之怡 徐异禾 孙浩澄 李俊熙
刘欣妍 曹昭阳 洪钰杰 李辰星
马小哲 刘欣妍 高琬忻 汪子涵
王子佑 蒋佳璇 占放 祝越 方瑞锴 徐润扬辛衎睿 刘昱琪
王佳阳 余少杰 吴敏书 方晓静
潘若晴 杜雨侨 徐菲 李程心 毕冉 牛昱涵
徐子轩 张梓墨 王瑾怡 蒋韦一 闫欣玥 王泊桐
沈博文 陈锡睿 许思睿 李雅珲 张弘毅 张天齐
尚方向、王墨林、王星玥、杜明泽
汪嘉伟 陈志翔 惠煜翔
卢思羽 李梓萌 王书恒 周子然 李思语
路畅 陈昕桐 张济罡 韩润博
傅宸轩 许雯萱 王倚丞 吴笑琪 李紫萱
诵读大赛6月3日下午场海选成绩（个人）：
编辑：汤家林
万家教育频道微信
微信号：parents365club
微信扫一扫，关注公众号
安徽资讯APP
扫一扫，安徽尽在您手中
万家热线今日合肥
微信扫一扫，使用小程序
每天10分钟，通晓合肥事
在线预约报名即送精美小礼品
你还等什么？赶快在线预约报名吧
预约课程即送日本大学练习册
优尔艺术课程卡
商 家：合肥优尔艺术体验中心
原 价：1500元
万家价：750元
地 址：望江西路华润五彩城写字楼203
短信快捷登录
合作账号登录
验证即登录，未注册将自动创建万家账号
发送验证码
6月23日，安徽省2018年高考成绩和高考录取分数线出炉，同时揭晓的还有安徽 ...
今日万家热线
扫描关注今日万家热线微信公共号
短信快捷登录
合作账号登录
验证即登录，未注册将自动创建万家账号
发送验证码高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图：
下面简单介绍下各个部分的作用与意义：
没有经过加密的数据。
用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。
AES加密函数
设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输入，则加密函数E会输出密文C。
经加密函数处理后的数据
AES解密函数
设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输入，则解密函数会输出明文P。
在这里简单介绍下对称加密算法与非对称加密算法的区别。
对称加密算法
加密和解密用到的密钥是相同的，这种加密方式加密速度非常快，适合经常发送数据的场合。缺点是密钥的传输比较麻烦。
非对称加密算法
加密和解密用的密钥是不同的，这种加密方式是用数学上的难解问题构造的，通常加密解密的速度比较慢，适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal。
实际中，一般是通过RSA加密AES的密钥，传输到接收方，接收方解密得到AES密钥，然后发送方和接收方用AES密钥来通信。
本文下面AES原理的介绍参考自《现代密码学教程》，AES的实现在介绍完原理后开始。
AES的基本结构
AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同，如下表所示：
密钥长度（32位比特字)
分组长度(32位比特字)
轮数在下面介绍，这里实现的是AES-128，也就是密钥的长度为128位，加密轮数为10轮。
上面说到，AES的加密公式为C = E(K,P)，在加密函数E中，会执行一个轮函数，并且执行10次这个轮函数，这个轮函数的前9次执行的操作是一样的，只有第10次有所不同。也就是说，一个明文分组会被加密10轮。AES的核心就是实现一轮中的所有操作。
AES的处理单位是字节，128位的输入明文分组P和输入密钥K都被分成16个字节，分别记为P = P0 P1 … P15 和 K = K0 K1 … K15。如，明文分组为P = abcdefghijklmnop,其中的字符a对应P0，p对应P15。一般地，明文分组用字节为单位的正方形矩阵描述，称为状态矩阵。在算法的每一轮中，状态矩阵的内容不断发生变化，最后的结果作为密文输出。该矩阵中字节的排列顺序为从上到下、从左至右依次排列，如下图所示：
现在假设明文分组P为”abcdefghijklmnop”，则对应上面生成的状态矩阵图如下：
上图中，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轮加密运算中的轮密钥加，如下图所示：
上图中，设K =
“abcdefghijklmnop”，则K0 = a, K15 = p, W[0] = K0 K1 K2 K3 = “abcd”。
AES的整体结构如下图所示，其中的W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第1轮到第9轮的轮函数一样，包括4个操作：字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外，在第一轮迭代之前，先将明文和原始密钥进行一次异或加密操作。
上图也展示了AES解密过程，解密过程仍为10轮，每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的，因此，解密操作的一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似，最后一轮不执行逆列混合，在第1轮解密之前，要执行1次密钥加操作。
下面分别介绍AES中一轮的4个操作阶段，这4分操作阶段使输入位得到充分的混淆。
一、字节代换
1.字节代换操作
AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒。
AES的S盒：
状态矩阵中的元素按照下面的方式映射为一个新的字节：把该字节的高4位作为行值，低4位作为列值，取出S盒或者逆S盒中对应的行的元素作为输出。例如，加密时，输出的字节S1为0x12,则查S盒的第0x01行和0x02列，得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下：
(第二个字符0xAB查表后应该是转换成0x62的，感谢细心的朋友指出，有空再重新画图更正了)
2.字节代换逆操作
逆字节代换也就是查逆S盒来变换，逆S盒如下：
二、行移位
1.行移位操作
行移位是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节，如下图所示：
2.行移位的逆变换
行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作，例如AES-128中，状态矩阵的第0行右移0字节，第1行右移1字节，第2行右移2字节，第3行右移3字节。
三、列混合
1.列混合操作
列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵，如下图的公式所示：
状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为下图所示：
其中，矩阵元素的乘法和加法都是定义在基于GF(2^8)上的二元运算,并不是通常意义上的乘法和加法。这里涉及到一些信息安全上的数学知识，不过不懂这些知识也行。其实这种二元运算的加法等价于两个字节的异或，乘法则复杂一点。对于一个8位的二进制数来说，使用域上的乘法乘以()等价于左移1位(低位补0)后，再根据情况同()进行异或运算，设S1 = (a7 a6 a5 a4 a3 a2 a1 a0)，刚0x02 * S1如下图所示：
也就是说，如果a7为1，则进行异或运算，否则不进行。
类似地，乘以()可以拆分成两次乘以()的运算：
乘以()可以拆分成先分别乘以()和()，再将两个乘积异或：
因此，我们只需要实现乘以2的函数，其他数值的乘法都可以通过组合来实现。
下面举个具体的例子,输入的状态矩阵如下：
下面，进行列混合运算：
以第一列的运算为例：
其它列的计算就不列举了，列混合后生成的新状态矩阵如下：
2.列混合逆运算
逆向列混合变换可由下图的矩阵乘法定义：
可以验证，逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵。
四、轮密钥加
轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作，如下图所示。其中，密钥Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字，包含4个字节，他们的生成算法下面在下面介绍。轮密钥加过程可以看成是字逐位异或的结果，也可以看成字节级别或者位级别的操作。也就是说，可以看成S0 S1 S2 S3 组成的32位字与W[4i]的异或运算。
轮密钥加的逆运算同正向的轮密钥加运算完全一致，这是因为异或的逆操作是其自身。轮密钥加非常简单，但却能够影响S数组中的每一位。
AES首先将初始密钥输入到一个4*4的状态矩阵中，如下图所示。
这个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部分组成：字循环、字节代换和轮常量异或，这3部分的作用分别如下。
a.字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
b.字节代换：对字循环的结果使用S盒进行字节代换。
c.轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
轮常量Rcon[j]是一个字，其值见下表。
01 00 00 00
02 00 00 00
04 00 00 00
08 00 00 00
10 00 00 00
20 00 00 00
40 00 00 00
80 00 00 00
1B 00 00 00
36 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盒的输入，输出为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的实现，对以上原理中的每一个小节进行实现讲解，讲解的时候会插入一些关键代码，完整的代码参见文章最后。文章最后提供两个完整的程序，一个能在linux下面编译运行，一个能在VC6.0下面编译通过。
AES算法实现
AES加密函数预览
aes加密函数中，首先进行密钥扩展，然后把128位长度的字符串读进一个4*4的整数数组中，这个数组就是状态矩阵。例如，pArray[0][0] = S0,pArray[1][0] = S1, pArray[0][1] = S4。这个读取过程是通过 convertToIntArray()函数来实现的。每个轮操作的函数都对pArray进行修改，也就是对状态矩阵进行混淆。在执行完10轮加密后，会把pArray转换回字符串，再存入明文p的字符数组中，所以，在加密完后，明文p的字符串中的字符就是加密后的字符了。这个转换过程是通过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");
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
extendKey(key);
int pArray[4][4];
for(int k = 0; k & k += 16) {
convertToIntArray(p + k, pArray);
addRoundKey(pArray, 0);
for(int 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);
1.密钥扩展的实现
在开始加密前，必须先获得第一轮加密用到的密钥，故先实现密钥扩展
下面是密钥扩展函数的实现，这个函数传入密钥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);
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位整数中读取这四个字节，之所以这样做是因为整数数组比较容易操作。然后调用leftLoop4int()函数把numArray数组中的4个元素循环左移1位。然后执行字节代换，通过getNumFromSBox()函数来获取S盒中相应的值来替换numArray中的值。接着通过mergeArrayToInt()函数把字节代换后的numArray合并回32位的整数，在进行轮常量异或后返回。
* 常量轮值表
static const int Rcon[10] = { 0x, 0x,
0x1b000000, 0x };
* 密钥扩展中的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]，这里的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 % 4;
static void shiftRows(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];
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)来实现。在这里，主要实现GFMul2()函数就行了，其它的都可以通过GFMul2()的组合来实现。举个例子吧，为计算下面这条等式，需要像下面这样调用函数
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 & 0x;
if(a7 != 0) {
result = result & 0x000000ff;
result = result ^ 0x1b;
static int GFMul3(int s) {
return GFMul2(s) ^
* GF上的二元运算
static int GFMul(int n, int s) {
if(n == 1)
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)
result = GFMul11(s);
else if(n == 0xd)
result = GFMul13(s);
else if(n == 0xe)
result = GFMul14(s);
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.轮密钥加的实现
轮密钥加的实现很简单，就是根据传入的轮数来把状态矩阵与相应的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的解密函数和加密函数有点不同，可以参考上面的等价解密流程图来理解，解密函数中调用的是各轮操作的逆函数。逆函数在这里就不详细讲解了，可以参考最后的完整代码。
* 参数 c: 密文的字符串数组。
* 参数 clen: 密文的长度。
* 参数 key: 密钥的字符串数组。
void deAes(char *c, int clen, char *key) {
int keylen = strlen(key);
if(clen == 0 || clen % 16 != 0) {
printf("密文字符长度必须为16的倍数！现在的长度为%d\n",clen);
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
extendKey(key);
int cArray[4][4];
for(int k = 0; k & 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);
完整的程序代码
#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);
#include &stdio.h&
#include &stdlib.h&
#include &string.h&
#include "aes.h"
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 };
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 & 0x;
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)
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]);
* 打印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 & 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 |
* 把一个4字节的数的第一、二、三、四个字节取出，
* 入进一个4个元素的整型数组里面。
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 % 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 |
* 常量轮值表
static const int Rcon[10] = { 0x, 0x,
0x1b000000, 0x };
* 密钥扩展中的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);
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];
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 & 0x;
if(a7 != 0) {
result = result & 0x000000ff;
result = result ^ 0x1b;
static int GFMul3(int s) {
return GFMul2(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) ^
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) ^
static int GFMul14(int s) {
return GFMul12(s) ^ GFMul2(s);
* GF上的二元运算
static int GFMul(int n, int s) {
if(n == 1)
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)
result = GFMul11(s);
else if(n == 0xd)
result = GFMul13(s);
else if(n == 0xe)
result = GFMul14(s);
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)
* 参数 p: 明文的字符串数组。
* 参数 plen: 明文的长度。
* 参数 key: 密钥的字符串数组。
void aes(char *p, int plen, char *key){
int keylen = strlen(key);
if(plen == 0 || plen % 16 != 0) {
printf("明文字符长度必须为16的倍数！\n");
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
extendKey(key);
int pArray[4][4];
for(int k = 0; k & k += 16) {
convertToIntArray(p + k, pArray);
addRoundKey(pArray, 0);
for(int 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]) {
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 -
for(int i = 3; i &= 0; i--) {
array[i] = temp[index];
index = index == -1 ? 3 :
* 逆行移位
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的倍数！现在的长度为%d\n",clen);
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
extendKey(key);
int cArray[4][4];
for(int k = 0; k & 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);
#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 & i++,str++){
if(*str == '\n'){
*str = '\0';
void printASCCI(char *str, int len) {
for(int i = 0; i & i++) {
c = (int)*str++;
c = c & 0x000000ff;
printf("0x%x ", c);
printf("\n");
void readPlainText(char *str, int *len) {
while(1) {
getString(str, MAXLEN);
plen = strlen(str);
if(plen != 0 && plen % 16 == 0) {
printf("你输入的明文为：%s\n", str);
printf("明文字符长度必须为16的倍数,现在的长度为%d\n", plen);
void writeStrToFile(char *str, int len, char *fileName) {
fp = fopen(fileName, "wb");
for(int i = 0; i & i++)
putc(str[i], fp);
fclose(fp);
void aesStrToFile(char *key) {
char p[MAXLEN];
printf("请输入你的明文，明文字符长度必须为16的倍数\n");
readPlainText(p,&plen);
printf("进行AES加密..................\n");
aes(p, plen, key);
printf("加密完后的明文的ASCCI为：\n");
printASCCI(p, plen);
char fileName[64];
printf("请输入你想要写进的文件名，比如'test.txt':\n");
if(scanf("%s", fileName) == 1) {
writeStrToFile(p, plen, fileName);
printf("已经将密文写进%s中了,可以在运行该程序的当前目录中找到它。\n", fileName);
int readStrFromFile(char *fileName, char *str) {
FILE *fp = fopen(fileName, "rb");
if(fp == NULL) {
printf("打开文件出错，请确认文件存在当前目录下！\n");
for(i = 0; i & MAXLEN && (str[i] = getc(fp)) != EOF; i++);
if(i &= MAXLEN) {
printf("解密文件过大！\n");
str[i] = '\0';
fclose(fp);
void deAesFile(char *key) {
char fileName[64];
char c[MAXLEN];
printf("请输入要解密的文件名，该文件必须和本程序在同一个目录\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("现在可以打开%s来查看解密后的密文了！\n",fileName);
void aesFile(char *key) {
char fileName[64];
char fileP[MAXLEN];
printf("请输入要加密的文件名，该文件必须和本程序在同一个目录\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("请输入16个字符的密钥：\n");
getString(key,17);
klen = strlen(key);
if(klen != 16){
printf("请输入16个字符的密钥,当前密钥的长度为%d\n",klen);
printf("你输入的密钥为：%s\n",key);
printf("输入's'表示要加密输入的字符串,并将加密后的内容写入到文件\n");
printf("请输入要功能选项并按回车，输入'f'表示要加密文件\n");
printf("输入'p'表示要解密文件\n");
if(scanf("%s",&c) == 1) {
if(c == 's')
aesStrToFile(key);
else if(c == 'p')
deAesFile(key);
else if(c == 'f')
aesFile(key);
通过下面的gcc命令来编译运行：
gcc -o aes aes.c main.c
由于VC6.0的编译器比较坑，要先声明，后使用变量，故要对代码进行相应的修改。
#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);
#include &stdio.h&
#include &stdlib.h&
#include &string.h&
#include "aes.h"
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 };
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 & 0x;
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)
return result & 0x000000ff;
* 把16个字符转变成4X4的数组，
* 该矩阵中字节的排列顺序为从上到下，
* 从左到右依次排列。
static void convertToIntArray(char *str, int pa[4][4]) {
int k = 0;
for(i = 0; i & 4; i++)
for(j = 0; j & 4; j++) {
pa[j][i] = getIntFromChar(str[k]);
* 打印4X4的数组
static void printArray(int a[4][4]) {
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) {
for(i = 0; i & i++)
printf("0x%x ", getIntFromChar(str[i]));
printf("\n");
* 把连续的4个字符合并成一个4字节的整型
static int getWordFromStr(char *str) {
int one, two, three,
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 |
* 把一个4字节的数的第一、二、三、四个字节取出，
* 入进一个4个元素的整型数组里面。
static void splitIntToArray(int num, int array[4]) {
int one, two,
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];
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 % 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 |
* 常量轮值表
static const int Rcon[10] = { 0x, 0x,
0x1b000000, 0x };
* 密钥扩展中的T函数
static int T(int num, int round) {
int numArray[4];
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() {
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) {
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);
w[i] = w[i - 4] ^ w[i - 1];
* 轮密钥加
static void addRoundKey(int array[4][4], int round) {
int warray[4];
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]){
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];
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 & 0x;
if(a7 != 0) {
result = result & 0x000000ff;
result = result ^ 0x1b;
static int GFMul3(int s) {
return GFMul2(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) ^
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) ^
static int GFMul14(int s) {
return GFMul12(s) ^ GFMul2(s);
* GF上的二元运算
static int GFMul(int n, int s) {
if(n == 1)
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)
result = GFMul11(s);
else if(n == 0xd)
result = GFMul13(s);
else if(n == 0xe)
result = GFMul14(s);
static void mixColumns(int array[4][4]) {
int tempArray[4][4];
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) {
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)
* 参数 p: 明文的字符串数组。
* 参数 plen: 明文的长度。
* 参数 key: 密钥的字符串数组。
void aes(char *p, int plen, char *key){
int keylen = strlen(key);
int pArray[4][4];
if(plen == 0 || plen % 16 != 0) {
printf("明文字符长度必须为16的倍数！\n");
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16。当前长度为%d\n",keylen);
extendKey(key);
for(k = 0; k & 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]) {
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];
for(i = 0; i & 4; i++)
temp[i] = array[i];
index = step % 4 == 0 ? 0 : step % 4;
index = 3 -
for(i = 3; i &= 0; i--) {
array[i] = temp[index];
index = index == -1 ? 3 :
* 逆行移位
static void deShiftRows(int array[4][4]) {
int rowTwo[4], rowThree[4], rowFour[4];
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];
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]) {
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的倍数！现在的长度为%d\n",clen);
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\n",keylen);
extendKey(key);
for(k = 0; k & k += 16) {
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);
Java 加密 AES 对称加密算法
JAVA 实现AES加密的两种方法
十分钟读懂AES加密算法
AES加密解密详解
理解AES加密解密的使用方法
图解AES加密算法
没有更多推荐了，