现在的位置: 首页 > 综合 > 正文

AES算法分析与实现

2013年10月10日 ⁄ 综合 ⁄ 共 20317字 ⁄ 字号 评论关闭

AUTHOR:   Jeffrey.zhu

                                    BLOG:http://blog.csdn.net/gueter/

 

 

 

 

 

 

 

AES算法的主要数学基础是抽象代数,其中算法中的许多运算是按单字节(8bits)和4字节(32bits)定义的,单字节可看成有限域GF(28)中的一个元素,而4字节则可以看成系数在GF(28)中并且次数小于4的多项式(亦可以理解为:GF(2564)),单字节上的运算有两种:有限域GF(28)上一个8次不可约多项式的模加、点乘(为方便代码实现,推出了X乘的概念),其中,这个不可约多项式为:m(x)= x8+x4+x3+x+1,类似地,4字节运算也分为两种:模加、乘法(为方便代码实现,推出了模乘的概念),而此时使用的模取M(x)=x4+1,由于x4+1=( x2+1)( x2+1)= ( x+1) ( x+1) ( x+1) ( x+1),即非不可约,导致非0多项式乘法逆元(逆元求取主要用到了欧几里德(Euclid)算法)不一定存在,所以在AES算法中,只限于乘一个固定的有逆元的多项式:a(x)={03}x3+{01}x2+{01}x+{02}。

AES(128bits密钥)主要加解密流程如下图所示:

AES算法加解密流程

 

 

 

图中左边是加密流程,右边是解密流程,其中,Plaintext为明文,Ciphertext为密文,密钥长度可变,可指定为128、192、256比特,不同密钥长度决定了加解密算法的轮数(128位:10轮,192位:12轮,256位:14轮),算法征集之初,6轮迭代便可抵抗当时世界上已知的所有攻击,AES标准中至少留了4轮余量,按照这种说法,可以推知轮数越多,AES破解难度越大,也就是密钥越长越安全,所以今年8月份有人说256bits密钥长度的AES算法被破解,而128bits未被破解是没有根据的。

理解AES需要知道以下两个概念:

l  状态:算法中间的结果也需要分组,称之为状态,状态可以用以字节为元素的矩阵阵列表示,该阵列有4行,列数Nb为分组长度除32;

l  种子密钥:以字节为元素的矩阵阵列描述,阵列为4行,列数Nk为密钥长度除32,其中根据种子密钥,可以推导出各轮子密钥w[ , ],此过程亦称作密钥扩展,针对不同密钥长度的密钥扩展算法可以参照阅读AES算法标准发布文档。

    1)下面简单分析一下AES(128bits密钥)的加密流程:

    AESEncrypt (State, ExpandedKey)

    {

        AddRoundKey (State, ExpandedKey); //种子密钥加,实际已经进行过子密钥扩展

        for (i=1; i <Nr; i ++)            //Nr根据密钥长度进行取值   

            Round (State, ExpandedKey+Nb* i);//加密轮函数

        FinalRound (State, ExpandedKey+Nb*Nr);//加密最后一轮轮函数

}

l  加密轮函数:

Round (State, RoundKey)

{

    ByteSub (State); //字节替代变换

    ShiftRow (State);//行移位变换

    MixColumn (State);//列混合变换

    AddRoundKey (State, RoundKey)//子密钥加(其实是一个简单的逐比特模2加)

}

l  加密最后一轮轮函数:

FinalRound (State, RoundKey)

{

    ByteSub (State);//字节替代变换

    ShiftRow (State);//行移位变换

    AddRoundKey (State, RoundKey);//子密钥加

}

以上加密过程具体算法可参照AES标准发布文档,需要注意的地方有以下几点:

l  字节替代变换是一种非线性变换,主要有两个可逆变换组成:求逆元、仿射变换,在具体实现中,根据两个过程的特点,逐一计算00~FF共256种字节替代变换结果,可以推导出一个固定的、加密用的S盒表;

l  列混合变换,即将状态的每一列视为有限域GF(28)上的一个多项式,并将此多项式与一个具有逆元的多项式进行多项式乘法,这个具有逆元的多项式即为前述的a(x)={03}x3+{01}x2+{01}x+{02},它的逆元为:a-1(x)={0b}x3+{0d}x2+{09}x+{0e};

l  基于种子密钥的子密钥扩展过程必须发生在调用加密函数之前,且加密完之后,传送到解密方的是种子密钥,也就是说,在调用解密函数之前也必须基于种子密钥进行子密钥扩展,此外,针对不同的密钥长度有不同的子密钥扩展算法,具体参照AES标准发布文档;

l  最后一轮轮函数之所以去掉列混合,是因为最后一轮的列混合并未增加AES算法的安全性,反而增加其实现难度,降低算法效率。

    2)下面简单分析一下AES(128bits密钥)的解密流程:

   

AESDecrypt (State, ExpandedKey)

{

    AddRoundKey (State, ExpandedKey+Nb*Nr);//子密钥加

    for (i= Nr-1; i >=1; i --)             // Nr根据密钥长度进行取值

        InvRound (State, InvMixColumn (ExpandedKey+Nb* i));//解密轮函数

    InvFinalRound (State, ExpandedKey);    //解密最后一轮轮函数

}

l  解密轮函数:

InvRound (State, RoundKey)

{

    InvShiftRow (State);//逆移位变换

    InvByteSub (State);//逆字节替代变换

    AddRoundKey (State, RoundKey);//子密钥加

    InvMixColumn (State); //逆列混合变换

}

l  解密最后一轮轮函数:

InvFinalRound (State, RoundKey)

{  

    InvShiftRow (State);//逆移位变换

    InvByteSub (State);//逆字节替代变换

    AddRoundKey (State, RoundKey);//逆列混合变换

}

以上解密过程具体算法可参照AES标准发布文档,需要注意的地方有以下几点:

l  加密过程中的子密钥加的逆变换即为同一子密钥继续加,所以的解密算法调用之前要对扩展后的子密钥进行逆序;

l  加解密是使用同一个S盒表?还是分别采用各自的S盒表?是一个时间复杂度和空间复杂度的权衡(作者在实现中将加解密S盒表分开做);

l  逆移位变换与逆字节替代变换之间是可以相互调换位置的。

 

 

 

源代码: 

 

 

 

  1. /*128bits密钥长度及分组长度AES加解密代码 
  2.  *作者:Jeffrey.zhu 
  3.  */  
  4.   
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. //#include <stdarg.h>  
  8. //#include <string.h>  
  9. //#include <signal.h>  
  10. //#include <ctype.h>  
  11.   
  12. typedef unsigned long u32;  
  13. typedef unsigned u16;  
  14. typedef unsigned char u8;  
  15.   
  16. static const u32 Te0[256] = {  
  17.     0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,  
  18.     0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,  
  19.     0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,  
  20.     0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,  
  21.     0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,  
  22.     0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,  
  23.     0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,  
  24.     0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,  
  25.     0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,  
  26.     0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,  
  27.     0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,  
  28.     0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,  
  29.     0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,  
  30.     0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,  
  31.     0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,  
  32.     0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,  
  33.     0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,  
  34.     0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,  
  35.     0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,  
  36.     0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,  
  37.     0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,  
  38.     0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,  
  39.     0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,  
  40.     0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,  
  41.     0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,  
  42.     0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,  
  43.     0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,  
  44.     0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,  
  45.     0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,  
  46.     0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,  
  47.     0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,  
  48.     0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,  
  49.     0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,  
  50.     0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,  
  51.     0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,  
  52.     0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,  
  53.     0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,  
  54.     0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,  
  55.     0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,  
  56.     0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,  
  57.     0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,  
  58.     0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,  
  59.     0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,  
  60.     0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,  
  61.     0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,  
  62.     0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,  
  63.     0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,  
  64.     0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,  
  65.     0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,  
  66.     0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,  
  67.     0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,  
  68.     0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,  
  69.     0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,  
  70.     0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,  
  71.     0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,  
  72.     0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,  
  73.     0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,  
  74.     0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,  
  75.     0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,  
  76.     0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,  
  77.     0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,  
  78.     0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,  
  79.     0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,  
  80.     0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,  
  81. };  
  82.   
  83. static const u32 Td0[256] = {  
  84.     0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,  
  85.     0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,  
  86.     0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,  
  87.     0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,  
  88.     0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,  
  89.     0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,  
  90.     0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,  
  91.     0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,  
  92.     0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,  
  93.     0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,  
  94.     0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,  
  95.     0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,  
  96.     0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,  
  97.     0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,  
  98.     0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,  
  99.     0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,  
  100.     0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,  
  101.     0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,  
  102.     0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,  
  103.     0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,  
  104.     0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,  
  105.     0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,  
  106.     0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,  
  107.     0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,  
  108.     0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,  
  109.     0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,  
  110.     0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,  
  111.     0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,  
  112.     0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,  
  113.     0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,  
  114.     0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,  
  115.     0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,  
  116.     0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,  
  117.     0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,  
  118.     0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,  
  119.     0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,  
  120.     0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,  
  121.     0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,  
  122.     0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,  
  123.     0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,  
  124.     0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,  
  125.     0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,  
  126.     0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,  
  127.     0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,  
  128.     0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,  
  129.     0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,  
  130.     0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,  
  131.     0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,  
  132.     0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,  
  133.     0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,  
  134.     0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,  
  135.     0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,  
  136.     0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,  
  137.     0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,  
  138.     0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,  
  139.     0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,  
  140.     0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,  
  141.     0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,  
  142.     0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,  
  143.     0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,  
  144.     0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,  
  145.     0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,  
  146.     0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,  
  147.     0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,  
  148. };  
  149.   
  150. static const u8 Td4s[256] = {  
  151.     0x52U, 0x09U, 0x6aU, 0xd5U, 0x30U, 0x36U, 0xa5U, 0x38U,  
  152.     0xbfU, 0x40U, 0xa3U, 0x9eU, 0x81U, 0xf3U, 0xd7U, 0xfbU,  
  153.     0x7cU, 0xe3U, 0x39U, 0x82U, 0x9bU, 0x2fU, 0xffU, 0x87U,  
  154.     0x34U, 0x8eU, 0x43U, 0x44U, 0xc4U, 0xdeU, 0xe9U, 0xcbU,  
  155.     0x54U, 0x7bU, 0x94U, 0x32U, 0xa6U, 0xc2U, 0x23U, 0x3dU,  
  156.     0xeeU, 0x4cU, 0x95U, 0x0bU, 0x42U, 0xfaU, 0xc3U, 0x4eU,  
  157.     0x08U, 0x2eU, 0xa1U, 0x66U, 0x28U, 0xd9U, 0x24U, 0xb2U,  
  158.     0x76U, 0x5bU, 0xa2U, 0x49U, 0x6dU, 0x8bU, 0xd1U, 0x25U,  
  159.     0x72U, 0xf8U, 0xf6U, 0x64U, 0x86U, 0x68U, 0x98U, 0x16U,  
  160.     0xd4U, 0xa4U, 0x5cU, 0xccU, 0x5dU, 0x65U, 0xb6U, 0x92U,  
  161.     0x6cU, 0x70U, 0x48U, 0x50U, 0xfdU, 0xedU, 0xb9U, 0xdaU,  
  162.     0x5eU, 0x15U, 0x46U, 0x57U, 0xa7U, 0x8dU, 0x9dU, 0x84U,  
  163.     0x90U, 0xd8U, 0xabU, 0x00U, 0x8cU, 0xbcU, 0xd3U, 0x0aU,  
  164.     0xf7U, 0xe4U, 0x58U, 0x05U, 0xb8U, 0xb3U, 0x45U, 0x06U,  
  165.     0xd0U, 0x2cU, 0x1eU, 0x8fU, 0xcaU, 0x3fU, 0x0fU, 0x02U,  
  166.     0xc1U, 0xafU, 0xbdU, 0x03U, 0x01U, 0x13U, 0x8aU, 0x6bU,  
  167.     0x3aU, 0x91U, 0x11U, 0x41U, 0x4fU, 0x67U, 0xdcU, 0xeaU,  
  168.     0x97U, 0xf2U, 0xcfU, 0xceU, 0xf0U, 0xb4U, 0xe6U, 0x73U,  
  169.     0x96U, 0xacU, 0x74U, 0x22U, 0xe7U, 0xadU, 0x35U, 0x85U,  
  170.     0xe2U, 0xf9U, 0x37U, 0xe8U, 0x1cU, 0x75U, 0xdfU, 0x6eU,  
  171.     0x47U, 0xf1U, 0x1aU, 0x71U, 0x1dU, 0x29U, 0xc5U, 0x89U,  
  172.     0x6fU, 0xb7U, 0x62U, 0x0eU, 0xaaU, 0x18U, 0xbeU, 0x1bU,  
  173.     0xfcU, 0x56U, 0x3eU, 0x4bU, 0xc6U, 0xd2U, 0x79U, 0x20U,  
  174.     0x9aU, 0xdbU, 0xc0U, 0xfeU, 0x78U, 0xcdU, 0x5aU, 0xf4U,  
  175.     0x1fU, 0xddU, 0xa8U, 0x33U, 0x88U, 0x07U, 0xc7U, 0x31U,  
  176.     0xb1U, 0x12U, 0x10U, 0x59U, 0x27U, 0x80U, 0xecU, 0x5fU,  
  177.     0x60U, 0x51U, 0x7fU, 0xa9U, 0x19U, 0xb5U, 0x4aU, 0x0dU,  
  178.     0x2dU, 0xe5U, 0x7aU, 0x9fU, 0x93U, 0xc9U, 0x9cU, 0xefU,  
  179.     0xa0U, 0xe0U, 0x3bU, 0x4dU, 0xaeU, 0x2aU, 0xf5U, 0xb0U,  
  180.     0xc8U, 0xebU, 0xbbU, 0x3cU, 0x83U, 0x53U, 0x99U, 0x61U,  
  181.     0x17U, 0x2bU, 0x04U, 0x7eU, 0xbaU, 0x77U, 0xd6U, 0x26U,  
  182.     0xe1U, 0x69U, 0x14U, 0x63U, 0x55U, 0x21U, 0x0cU, 0x7dU,  
  183. };  
  184.   
  185. static const u8 rcons[] = {  
  186.     0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36  
  187. };  
  188.   
  189. #define RCON(i) (rcons[(i)] << 24)  
  190.   
  191. static inline u32 rotr(u32 val, int bits)  
  192. {  
  193.     return (val >> bits) | (val << (32 - bits));  
  194. }  
  195.   
  196. #define TE0(i) Te0[((i) >> 24) & 0xff]  
  197. #define TE1(i) rotr(Te0[((i) >> 16) & 0xff], 8)  
  198. #define TE2(i) rotr(Te0[((i) >> 8) & 0xff], 16)  
  199. #define TE3(i) rotr(Te0[(i) & 0xff], 24)  
  200. #define TE41(i) ((Te0[((i) >> 24) & 0xff] << 8) & 0xff000000)  
  201. #define TE42(i) (Te0[((i) >> 16) & 0xff] & 0x00ff0000)  
  202. #define TE43(i) (Te0[((i) >> 8) & 0xff] & 0x0000ff00)  
  203. #define TE44(i) ((Te0[(i) & 0xff] >> 8) & 0x000000ff)  
  204. #define TE421(i) ((Te0[((i) >> 16) & 0xff] << 8) & 0xff000000)  
  205. #define TE432(i) (Te0[((i) >> 8) & 0xff] & 0x00ff0000)  
  206. #define TE443(i) (Te0[(i) & 0xff] & 0x0000ff00)  
  207. #define TE414(i) ((Te0[((i) >> 24) & 0xff] >> 8) & 0x000000ff)  
  208. #define TE4(i) ((Te0[(i)] >> 8) & 0x000000ff)  
  209.   
  210. #define TD0(i) Td0[((i) >> 24) & 0xff]  
  211. #define TD1(i) rotr(Td0[((i) >> 16) & 0xff], 8)  
  212. #define TD2(i) rotr(Td0[((i) >> 8) & 0xff], 16)  
  213. #define TD3(i) rotr(Td0[(i) & 0xff], 24)  
  214. #define TD41(i) (Td4s[((i) >> 24) & 0xff] << 24)  
  215. #define TD42(i) (Td4s[((i) >> 16) & 0xff] << 16)  
  216. #define TD43(i) (Td4s[((i) >> 8) & 0xff] << 8)  
  217. #define TD44(i) (Td4s[(i) & 0xff])  
  218. #define TD0_(i) Td0[(i) & 0xff]  
  219. #define TD1_(i) rotr(Td0[(i) & 0xff], 8)  
  220. #define TD2_(i) rotr(Td0[(i) & 0xff], 16)  
  221. #define TD3_(i) rotr(Td0[(i) & 0xff], 24)  
  222.   
  223. #define AES_PRIV_SIZE (4 * 44)  
  224.   
  225. #define GETU32(pt) (((u32)(pt)[0] << 24) ^ ((u32)(pt)[1] << 16) ^ /  
  226. ((u32)(pt)[2] <<  8) ^ ((u32)(pt)[3])) /*u8->u32*/  
  227.   
  228. #define PUTU32(ct, st) { /  
  229. (ct)[0] = (u8)((st) >> 24); (ct)[1] = (u8)((st) >> 16); /  
  230. (ct)[2] = (u8)((st) >>  8); (ct)[3] = (u8)(st); }  
  231.   
  232. /*加密函数,已测试*/  
  233. static void aes_encrypt(u8 pt[16],u8 ct[16],const u8 cipherKey[],size_t keyLen)  
  234. {  
  235.   u32 *rk;  
  236.   int Nr=10,i,j;  
  237.   u32 temp;  
  238.   u32 s0, s1, s2, s3, t0, t1, t2, t3;  
  239.     
  240.   if(16 != keyLen)  
  241.   return;  
  242.   rk=malloc(AES_PRIV_SIZE);//problem??4*4*11?  
  243.   if(NULL==rk)//write "=" wrong here  
  244.   return;  
  245.        
  246.   rk[0]=GETU32(cipherKey     );  
  247.   rk[1]=GETU32(cipherKey + 4 );   
  248.   rk[2]=GETU32(cipherKey + 8 );  
  249.   rk[3]=GETU32(cipherKey + 12 );  
  250.          
  251.   for(i=0; i<10; i++)  
  252.   {  
  253.     temp=rk[3];  
  254.     rk[4]=rk[0]^TE421(temp)^TE432(temp)^TE443(temp)^TE414(temp)^RCON(i);  
  255.     rk[5]=rk[1]^rk[4];  
  256.     rk[6]=rk[2]^rk[5];  
  257.     rk[7]=rk[3]^rk[6];  
  258.     rk +=4;  
  259.   }   
  260.     
  261.   rk-=40;               
  262.           
  263.   s0=GETU32(pt    )^rk[0];  
  264.   s1=GETU32(pt + 4)^rk[1];  
  265.   s2=GETU32(pt + 8)^rk[2];  
  266.   s3=GETU32(pt + 12)^rk[3];  
  267.   
  268.   /*单轮*/  
  269.   #define ROUND(i,d,s) /  
  270.   d##0 = TE0(s##0) ^ TE1(s##1) ^ TE2(s##2) ^ TE3(s##3) ^ rk[4 * i]; /  
  271.   d##1 = TE0(s##1) ^ TE1(s##2) ^ TE2(s##3) ^ TE3(s##0) ^ rk[4 * i + 1]; /  
  272.   d##2 = TE0(s##2) ^ TE1(s##3) ^ TE2(s##0) ^ TE3(s##1) ^ rk[4 * i + 2]; /  
  273.   d##3 = TE0(s##3) ^ TE1(s##0) ^ TE2(s##1) ^ TE3(s##2) ^ rk[4 * i + 3]  
  274.   
  275.   ROUND(1,t,s);  
  276.   ROUND(2,s,t);  
  277.   ROUND(3,t,s);  
  278.   ROUND(4,s,t);  
  279.   ROUND(5,t,s);  
  280.   ROUND(6,s,t);  
  281.   ROUND(7,t,s);  
  282.   ROUND(8,s,t);  
  283.   ROUND(9,t,s);  
  284.   rk += Nr << 2;  
  285.       
  286. #undef ROUND  
  287.   s0 = TE41(t0) ^ TE42(t1) ^ TE43(t2) ^ TE44(t3) ^ rk[0];  
  288.     PUTU32(ct     , s0);  
  289.     s1 = TE41(t1) ^ TE42(t2) ^ TE43(t3) ^ TE44(t0) ^ rk[1];  
  290.     PUTU32(ct +  4, s1);  
  291.     s2 = TE41(t2) ^ TE42(t3) ^ TE43(t0) ^ TE44(t1) ^ rk[2];  
  292.     PUTU32(ct +  8, s2);  
  293.     s3 = TE41(t3) ^ TE42(t0) ^ TE43(t1) ^ TE44(t2) ^ rk[3];  
  294.     PUTU32(ct + 12, s3);  
  295.       
  296.     rk -= 40;  
  297.     free(rk);  
  298. }  
  299.   
  300. /*解密函数*/  
  301. static void aes_decrypt(u8 ct[16],  u8 pt[16], const u8 cipherKey[], size_t keyLen)  
  302. {     
  303.     u32 *rk;  
  304.       
  305.     if(16 != keyLen)  
  306.         return;  
  307.     rk=malloc(AES_PRIV_SIZE);  
  308.     if(NULL == rk)  
  309.         return;  
  310.           
  311.         int Nr=10,i,j;  
  312.       u32 temp;  
  313.       
  314.           rk[0]=GETU32(cipherKey     );  
  315.         rk[1]=GETU32(cipherKey + 4 );     
  316.         rk[2]=GETU32(cipherKey + 8 );  
  317.         rk[3]=GETU32(cipherKey + 12 );  
  318.   
  319.     for(i=0; i<10; i++)  
  320.     {  
  321.         temp=rk[3];  
  322.         rk[4]=rk[0]^TE421(temp)^TE432(temp)^TE443(temp)^TE414(temp)^RCON(i);  
  323.         rk[5]=rk[1]^rk[4];  
  324.         rk[6]=rk[2]^rk[5];  
  325.         rk[7]=rk[3]^rk[6];  
  326.         rk +=4;  
  327.     }  
  328.       
  329.         rk-=40;   
  330.     for (i = 0, j = 4*Nr; i < j; i += 4, j -= 4)   
  331.     {  
  332.         temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;  
  333.         temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;  
  334.         temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;  
  335.         temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;  
  336.     }     
  337.     #if 0  
  338.     temp = rk[i    ]; rk[i    ] = rk[j + 3]; rk[j + 3] = temp;  
  339.         temp = rk[i + 1]; rk[i + 1] = rk[j + 2]; rk[j + 2] = temp;  
  340.         temp = rk[i + 2]; rk[i + 2] = rk[j + 1]; rk[j + 1] = temp;  
  341.         temp = rk[i + 3]; rk[i + 3] = rk[j    ]; rk[j    ] = temp;  
  342.         #endif  
  343.           
  344.           int k;  
  345.         for(k=0;k<44;k++)  
  346.         printf("/n de_rk is:%uld/n",rk[k]);   
  347. //          here is right  
  348.                   
  349.     /* apply the inverse MixColumn transform to all round keys but the 
  350.      * first and the last: */  
  351.     for (i = 1; i < Nr; i++)   
  352.     {  
  353.         rk += 4;  
  354.         for (j = 0; j < 4; j++)   
  355.         {  
  356.             rk[j] = TD0_(TE4((rk[j] >> 24)       )) ^  
  357.                 TD1_(TE4((rk[j] >> 16) & 0xff)) ^  
  358.                 TD2_(TE4((rk[j] >>  8) & 0xff)) ^  
  359.                 TD3_(TE4((rk[j]      ) & 0xff));  
  360.         }  
  361.     }  
  362.       
  363.     u32 s0, s1, s2, s3, t0, t1, t2, t3;  
  364.     int r;  
  365.     /* 
  366.      * map byte array block to cipher state 
  367.      * and add initial round key: 
  368.      */  
  369.     s0 = GETU32(ct     ) ^ rk[0];  
  370.     s1 = GETU32(ct +  4) ^ rk[1];  
  371.     s2 = GETU32(ct +  8) ^ rk[2];  
  372.     s3 = GETU32(ct + 12) ^ rk[3];  
  373.                           
  374. #define ROUND(i,d,s) /  
  375. d##0 = TD0(s##0) ^ TD1(s##3) ^ TD2(s##2) ^ TD3(s##1) ^ rk[4 * i]; /  
  376. d##1 = TD0(s##1) ^ TD1(s##0) ^ TD2(s##3) ^ TD3(s##2) ^ rk[4 * i + 1]; /  
  377. d##2 = TD0(s##2) ^ TD1(s##1) ^ TD2(s##0) ^ TD3(s##3) ^ rk[4 * i + 2]; /  
  378. d##3 = TD0(s##3) ^ TD1(s##2) ^ TD2(s##1) ^ TD3(s##0) ^ rk[4 * i + 3]  
  379.   
  380.     ROUND(1,t,s);             
  381.     ROUND(2,s,t);  
  382.     ROUND(3,t,s);  
  383.     ROUND(4,s,t);     
  384.     ROUND(5,t,s);     
  385.     ROUND(6,s,t);  
  386.     ROUND(7,t,s);  
  387.     ROUND(8,s,t);  
  388.     ROUND(9,t,s);  
  389.     rk += Nr << 2;  
  390.               
  391. #undef ROUND  
  392.     /* 
  393.      * apply last round and 
  394.      * map cipher state to byte array block: 
  395.      */  
  396.     s0 = TD41(t0) ^ TD42(t3) ^ TD43(t2) ^ TD44(t1) ^ rk[0];  
  397.     PUTU32(pt     , s0);  
  398.     s1 = TD41(t1) ^ TD42(t0) ^ TD43(t3) ^ TD44(t2) ^ rk[1];  
  399.     PUTU32(pt +  4, s1);  
  400.     s2 = TD41(t2) ^ TD42(t1) ^ TD43(t0) ^ TD44(t3) ^ rk[2];  
  401.     PUTU32(pt +  8, s2);  
  402.     s3 = TD41(t3) ^ TD42(t2) ^ TD43(t1) ^ TD44(t0) ^ rk[3];  
  403.     PUTU32(pt + 12, s3);      
  404.       
  405.     rk-=40;  
  406.     free(rk);  
  407. }  
  408.   
  409. /*测试主函数*/  
  410. int main(int argc, char *argv[])  
  411. {  
  412.       u8 p_text[16];  
  413.       u8 c_text[16];      
  414.       u8 p1_text[16];  
  415.       u8 c1_text[16];  
  416.       memset(p_text,0,16);  
  417.       memset(c_text,0,16);  
  418.       memset(p1_text,0,16);  
  419.       memset(c1_text,0,16);  
  420.         
  421. //    const u8 cipherKey[16]={43,126,21,22,40,174,210,166,171,247,21,136,9,207,79,60};                            
  422.           const u8 cipherKey[16]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                  
  423. //      const u8 cipherKey[]="00000000000000000000000000000000";//is a wrong way  
  424. #if 0  
  425.           printf("Data before encrypt is:/n");  
  426.       int k;  
  427.       for(k=0;k<16;k++)  
  428.                 printf("%u ",p_text[k]);  
  429.         aes_encrypt(p_text,c_text,cipherKey,16);  
  430.           printf("/nData after encrypt is:/n");  
  431.       int h;  
  432.       for(h=0;h<16;h++)  
  433.             printf("%u ",c_text[h]);  
  434. #endif        
  435.       aes_decrypt(c1_text,p1_text,cipherKey,16);  
  436.           printf("/ndata after decrypt is:/n");  
  437.             int g;  
  438.       for(g=0;g<16;g++)  
  439.             printf("%u ",p1_text[g]);  
  440.         printf("/n");                 
  441.         return 0;  
  442. }  

抱歉!评论已关闭.