AES加密解密算法的C代码实现

最新推荐文章于 2024-03-05 10:07:19 发布
最新推荐文章于 2024-03-05 10:07:19 发布
阅读量9.1k 收藏 9
点赞数


AES 加密解密的原理我就不说了， 弟兄们自己上百度去查， 文章很多。

 

我这里只列出从网上获取的代码的实现， 我修改了一些， 可以很方便的使用到你的代码里面。

 

AES 比DES算法的强度更强。AES使用128位的加密密钥就足够了， 不需要使用更长的密钥。毕竟密钥太长浪费CPU资源。

 

AES.h头文件

 

[c-sharp] view plain copy print ?
  1. #ifndef _AES_H  
  2. #define _AES_H  
  3.   
  4. /*************** Header files *********************************************/  
  5. #include <stdlib.h>  
  6. #include <string.h>  
  7. #include <memory.h>  
  8. //#include "cryptcom.h"  
  9.  
  10.  
  11. #define AES_ModeType  AI_ECB  
  12. #define AES_PadType   AI_PKCS_PADDING  
  13.   
  14. /*************** Assertions ***********************************************/  
  15.     Define the Endianness     
  16. #undef BIG_ENDIAN  
  17. #undef LITTLE_ENDIAN  
  18.  
  19. #define USER_LITTLE_ENDIAN  
  20.  
  21. #if defined(USER_BIG_ENDIAN)  
  22.     #define BIG_ENDIAN  
  23. #elif defined(USER_LITTLE_ENDIAN)  
  24.     #define LITTLE_ENDIAN  
  25. #else  
  26.     #if 0  
  27.         #define BIG_ENDIAN      //  Big-Endian machine with pointer casting  
  28.     #elif defined(_MSC_VER)  
  29.         #define LITTLE_ENDIAN   //  Little-Endian machine with pointer casting  
  30.     #else  
  31.         #error  
  32.     #endif  
  33. #endif  
  34.   
  35. /*************** Macros ***************************************************/  
  36.     rotate by using shift operations      
  37. #if defined(_MSC_VER)  
  38.     #define ROTL_DWORD(x, n) _lrotl((x), (n))  
  39.     #define ROTR_DWORD(x, n) _lrotr((x), (n))  
  40. #else  
  41.     #define ROTL_DWORD(x, n) ( (DWORD)((x) << (n)) | (DWORD)((x) >> (32-(n))) )  
  42.     #define ROTR_DWORD(x, n) ( (DWORD)((x) >> (n)) | (DWORD)((x) << (32-(n))) )  
  43. #endif  
  44.   
  45.     reverse the byte order of DWORD(DWORD:4-bytes integer) and WORD.  
  46. #define ENDIAN_REVERSE_DWORD(dwS)   ( (ROTL_DWORD((dwS),  8) & 0x00ff00ff) | (ROTL_DWORD((dwS), 24) & 0xff00ff00) )  
  47.   
  48.     move DWORD type to BYTE type and BYTE type to DWORD type  
  49. #if defined(BIG_ENDIAN)         Big-Endian machine  
  50.     #define BIG_B2D(B, D)       D = *(DWORD *)(B)  
  51.     #define BIG_D2B(D, B)       *(DWORD *)(B) = (DWORD)(D)  
  52.     #define LITTLE_B2D(B, D)    D = ENDIAN_REVERSE_DWORD(*(DWORD *)(B))  
  53.     #define LITTLE_D2B(D, B)    *(DWORD *)(B) = ENDIAN_REVERSE_DWORD(D)  
  54. #elif defined(LITTLE_ENDIAN)        Little-Endian machine  
  55.     #define BIG_B2D(B, D)       D = ENDIAN_REVERSE_DWORD(*(DWORD *)(B))  
  56.     #define BIG_D2B(D, B)       *(DWORD *)(B) = ENDIAN_REVERSE_DWORD(D)  
  57.     #define LITTLE_B2D(B, D)    D = *(DWORD *)(B)  
  58.     #define LITTLE_D2B(D, B)    *(DWORD *)(B) = (DWORD)(D)  
  59. #else  
  60.     #error ERROR : Invalid DataChangeType  
  61. #endif  
  62.   
  63. /*************** Definitions / Macros *************************************/  
  64.     泅犁 酒贰狼 4俺 规侥阑 瘤盔茄促.  
  65. #define AI_ECB                  1  
  66. #define AI_CBC                  2  
  67. #define AI_OFB                  3  
  68. #define AI_CFB                  4  
  69.     泅犁 酒贰狼 滴 padding阑 瘤盔茄促.  
  70. #define AI_NO_PADDING           1   //  Padding 绝澜(涝仿捞 16官捞飘狼 硅荐)  
  71. #define AI_PKCS_PADDING         2   //  padding登绰 官捞飘 荐肺 padding  
  72.   
  73.     AES俊 包访等 惑荐甸  
  74. #define AES_BLOCK_LEN           16      //  in BYTEs  
  75. #define AES_USER_KEY_LEN        32      //  (16,24,32) in BYTEs  
  76. #define AES_NO_ROUNDS           10  
  77. #define AES_NO_ROUNDKEY         68      //  in DWORDs  
  78.   
  79. /*************** New Data Types *******************************************/  
  80.     Determine data types depand on the processor and compiler.  
  81. #define BOOL    int                 //  1-bit data type  
  82. #define BYTE    unsigned char       //  unsigned 1-byte data type  
  83. #define WORD    unsigned short int  //  unsigned 2-bytes data type  
  84. #define DWORD   unsigned int        //  unsigned 4-bytes data type  
  85. #define RET_VAL     DWORD           //  return values  
  86.   
  87.     AES..  
  88. typedef struct{  
  89.     DWORD       ModeID;                     //  ECB or CBC  
  90.     DWORD       PadType;                    //  喉废鞠龋狼 Padding type  
  91.     BYTE        IV[AES_BLOCK_LEN];          //  Initial Vector  
  92.     BYTE        ChainVar[AES_BLOCK_LEN];    //  Chaining Variable  
  93.     BYTE        Buffer[AES_BLOCK_LEN];      //  Buffer for unfilled block  
  94.     DWORD       BufLen;                     //  Buffer狼 蜡瓤 官捞飘 荐  
  95.     DWORD       RoundKey[AES_NO_ROUNDKEY];  //  扼款靛 虐狼 DWORD 荐  
  96. } AES_ALG_INFO;  
  97.   
  98. /*************** Constant (Error Code) ************************************/  
  99.     Error Code - 沥府窍绊, 利寸洒 免仿秦具 窃.  
  100. #define CTR_SUCCESS                 0  
  101. #define CTR_FATAL_ERROR             0x1001  
  102. #define CTR_INVALID_USERKEYLEN      0x1002  //  厚剐虐狼 辨捞啊 何利例窃.  
  103. #define CTR_PAD_CHECK_ERROR         0x1003  //    
  104. #define CTR_DATA_LEN_ERROR          0x1004  //  乞巩狼 辨捞啊 何利例窃.  
  105. #define CTR_CIPHER_LEN_ERROR        0x1005  //  鞠龋巩捞 喉废狼 硅荐啊 酒丛.  
  106.  
  107. #ifdef __cplusplus  
  108. extern "C" {  
  109. #endif  
  110.   
  111. /*************** Prototypes ***********************************************/  
  112.     单捞鸥 鸥涝 AES_ALG_INFO俊 mode, padding 辆幅 棺 IV 蔼阑 檬扁拳茄促.  
  113. void    AES_SetAlgInfo(  
  114.         DWORD           ModeID,  
  115.         DWORD           PadType,  
  116.         BYTE            *IV,  
  117.         AES_ALG_INFO    *AlgInfo);  
  118.   
  119.     涝仿等 AES_USER_KEY_LEN官牢飘狼 厚剐虐肺 扼款靛 虐 积己  
  120. RET_VAL AES_EncKeySchedule(  
  121.         BYTE            *UserKey,       //  荤侩磊 厚剐虐甫 涝仿窃.  
  122.         DWORD           UserKeyLen,  
  123.         AES_ALG_INFO    *AlgInfo);      //  鞠汗龋侩 Round Key啊 历厘凳.  
  124. RET_VAL AES_DecKeySchedule(  
  125.         BYTE            *UserKey,       //  荤侩磊 厚剐虐甫 涝仿窃.  
  126.         DWORD           UserKeyLen,  
  127.         AES_ALG_INFO    *AlgInfo);      //  鞠汗龋侩 Round Key啊 历厘凳.  
  128.   
  129.     Init/Update/Final 屈侥阑 鞠龋拳.  
  130. RET_VAL AES_EncInit(  
  131.         AES_ALG_INFO    *AlgInfo);  
  132. RET_VAL AES_EncUpdate(  
  133.         AES_ALG_INFO    *AlgInfo,  
  134.         BYTE            *PlainTxt,      //  乞巩捞 涝仿凳.  
  135.         DWORD           PlainTxtLen,  
  136.         BYTE            *CipherTxt,     //  鞠龋巩捞 免仿凳.  
  137.         DWORD           *CipherTxtLen);  
  138. RET_VAL AES_EncFinal(  
  139.         AES_ALG_INFO    *AlgInfo,  
  140.         BYTE            *CipherTxt,     //  鞠龋巩捞 免仿凳.  
  141.         DWORD           *CipherTxtLen);  
  142.   
  143.     Init/Update/Final 屈侥阑 汗龋拳.  
  144. RET_VAL AES_DecInit(  
  145.         AES_ALG_INFO    *AlgInfo);  
  146. RET_VAL AES_DecUpdate(  
  147.         AES_ALG_INFO    *AlgInfo,  
  148.         BYTE            *CipherTxt,     //  鞠龋巩捞 涝仿凳.  
  149.         DWORD           CipherTxtLen,  
  150.         BYTE            *PlainTxt,      //  汗龋巩捞 免仿凳.  
  151.         DWORD           *PlainTxtLen);  
  152. RET_VAL AES_DecFinal(  
  153.         AES_ALG_INFO    *AlgInfo,  
  154.         BYTE            *PlainTxt,      //  汗龋巩捞 免仿凳.  
  155.         DWORD           *PlainTxtLen);  
  156.   
  157. /*************** END OF FILE **********************************************/  
  158.  
  159.  
  160. #ifdef __cplusplus  
  161. }  
  162. #endif  
  163.  
  164. #endif  //  _AES_H  

 

 

AESENC.C文件

 

[cpp] view plain copy print ?
  1. /*************** Header files *********************************************/  
  2. #include "aes.h"  
  3.   
  4. /*************** Assertions ***********************************************/  
  5.   
  6. /*************** Definitions / Macros  ************************************/  
  7. #define BlockCopy(pbDst, pbSrc) {                   /  
  8.     ((DWORD *)(pbDst))[0] = ((DWORD *)(pbSrc))[0];  /  
  9.     ((DWORD *)(pbDst))[1] = ((DWORD *)(pbSrc))[1];  /  
  10.     ((DWORD *)(pbDst))[2] = ((DWORD *)(pbSrc))[2];  /  
  11.     ((DWORD *)(pbDst))[3] = ((DWORD *)(pbSrc))[3];  /  
  12. }  
  13. #define BlockXor(pbDst, phSrc1, phSrc2) {           /  
  14.     ((DWORD *)(pbDst))[0] = ((DWORD *)(phSrc1))[0]  /  
  15.                           ^ ((DWORD *)(phSrc2))[0]; /  
  16.     ((DWORD *)(pbDst))[1] = ((DWORD *)(phSrc1))[1]  /  
  17.                           ^ ((DWORD *)(phSrc2))[1]; /  
  18.     ((DWORD *)(pbDst))[2] = ((DWORD *)(phSrc1))[2]  /  
  19.                           ^ ((DWORD *)(phSrc2))[2]; /  
  20.     ((DWORD *)(pbDst))[3] = ((DWORD *)(phSrc1))[3]  /  
  21.                           ^ ((DWORD *)(phSrc2))[3]; /  
  22. }  
  23.   
  24. /*************** New Data Types *******************************************/  
  25.   
  26. /*************** Global Variables *****************************************/  
  27.   
  28. /*************** Prototypes ***********************************************/  
  29. void    AES_Encrypt(  
  30.         void        *CipherKey,     //  鞠/汗龋侩 Round Key  
  31.         BYTE        *Data);         //  涝免仿阑 困茄 喉废阑 啊府虐绰 pointer  
  32. void    AES_Decrypt(  
  33.         void        *CipherKey,     //  鞠/汗龋侩 Round Key  
  34.         BYTE        *Data);         //  涝免仿阑 困茄 喉废阑 啊府虐绰 pointer  
  35.   
  36. /*************** Constants ************************************************/  
  37.   
  38. /*************** Constants ************************************************/  
  39.   
  40. /*************** Macros ***************************************************/  
  41.   
  42. /*************** Global Variables *****************************************/  
  43.   
  44. /*************** Function ************************************************* 
  45. * 
  46. */  
  47. void    AES_SetAlgInfo(  
  48.         DWORD           ModeID,  
  49.         DWORD           PadType,  
  50.         BYTE            *IV,  
  51.         AES_ALG_INFO    *AlgInfo)  
  52. {  
  53.     AlgInfo->ModeID = ModeID;  
  54.     AlgInfo->PadType = PadType;  
  55.   
  56.     if( IV!=NULL )  
  57.         memcpy(AlgInfo->IV, IV, AES_BLOCK_LEN);  
  58.     else  
  59.         memset(AlgInfo->IV, 0, AES_BLOCK_LEN);  
  60. }  
  61.   
  62. /*************** Function ************************************************* 
  63. * 
  64. */  
  65. static RET_VAL PaddSet(  
  66.             BYTE    *pbOutBuffer,  
  67.             DWORD   dRmdLen,  
  68.             DWORD   dBlockLen,  
  69.             DWORD   dPaddingType)  
  70. {  
  71.     DWORD dPadLen;  
  72.   
  73.     switch( dPaddingType )   
  74.     {  
  75.         case AI_NO_PADDING :  
  76.             if( dRmdLen==0 )    return 0;  
  77.             else                return CTR_DATA_LEN_ERROR;  
  78.   
  79.         case AI_PKCS_PADDING :  
  80.             dPadLen = dBlockLen - dRmdLen;  
  81.             memset(pbOutBuffer+dRmdLen, (char)dPadLen, (int)dPadLen);  
  82.             return dPadLen;  
  83.   
  84.         default :  
  85.             return CTR_FATAL_ERROR;  
  86.     }  
  87. }  
  88.   
  89. /*************** Function ************************************************* 
  90. * 
  91. */  
  92. static RET_VAL PaddCheck(  
  93.             BYTE    *pbOutBuffer,  
  94.             DWORD   dBlockLen,  
  95.             DWORD   dPaddingType)  
  96. {  
  97.     DWORD i, dPadLen;  
  98.   
  99.     switch( dPaddingType ) {  
  100.         case AI_NO_PADDING :  
  101.             return 0;           //  padding等 单捞鸥啊 0官捞飘烙.  
  102.   
  103.         case AI_PKCS_PADDING :  
  104.             dPadLen = pbOutBuffer[dBlockLen-1];  
  105.             if( ((int)dPadLen<=0) || (dPadLen>(int)dBlockLen) )  
  106.                 return CTR_PAD_CHECK_ERROR;  
  107.             for( i=1; i<=dPadLen; i++)  
  108.                 if( pbOutBuffer[dBlockLen-i] != dPadLen )  
  109.                     return CTR_PAD_CHECK_ERROR;  
  110.             return dPadLen;  
  111.   
  112.         default :  
  113.             return CTR_FATAL_ERROR;  
  114.     }  
  115. }  
  116.   
  117. /************************************************************************** 
  118. * 
  119. */  
  120. RET_VAL AES_EncInit(  
  121.         AES_ALG_INFO    *AlgInfo)  
  122. {  
  123.     AlgInfo->BufLen = 0;  
  124.     if( AlgInfo->ModeID!=AI_ECB )  
  125.         memcpy(AlgInfo->ChainVar, AlgInfo->IV, AES_BLOCK_LEN);  
  126.     return CTR_SUCCESS;  
  127. }  
  128.   
  129. /************************************************************************** 
  130. * 
  131. */  
  132. static RET_VAL ECB_EncUpdate(  
  133.         AES_ALG_INFO    *AlgInfo,       //    
  134.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  135.         DWORD       PlainTxtLen,    //  涝仿登绰 乞巩狼 官捞飘 荐  
  136.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  137.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  138. {  
  139.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  140.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  141.   
  142.     //  
  143.     *CipherTxtLen = BufLen + PlainTxtLen;  
  144.   
  145.     //  No one block  
  146.     if( *CipherTxtLen<BlockLen )   
  147.     {  
  148.         memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)PlainTxtLen);  
  149.         AlgInfo->BufLen += PlainTxtLen;  
  150.         *CipherTxtLen = 0;  
  151.         return CTR_SUCCESS;  
  152.     }  
  153.   
  154.     //  control the case that PlainTxt and CipherTxt are the same buffer  
  155.     if( PlainTxt==CipherTxt )  
  156.         return CTR_FATAL_ERROR;  
  157.   
  158.     //  first block  
  159.     memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen));  
  160.     PlainTxt += BlockLen - BufLen;  
  161.     PlainTxtLen -= BlockLen - BufLen;  
  162.   
  163.     //  core part  
  164.     BlockCopy(CipherTxt, AlgInfo->Buffer);  
  165.     AES_Encrypt(ScheduledKey, CipherTxt);  
  166.     CipherTxt += BlockLen;  
  167.     while( PlainTxtLen>=BlockLen )   
  168.     {  
  169.         BlockCopy(CipherTxt, PlainTxt);  
  170.         AES_Encrypt(ScheduledKey, CipherTxt);  
  171.         PlainTxt += BlockLen;  
  172.         CipherTxt += BlockLen;  
  173.         PlainTxtLen -= BlockLen;  
  174.     }  
  175.   
  176.     //  save remained data  
  177.     memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen);  
  178.     AlgInfo->BufLen = PlainTxtLen;  
  179.     *CipherTxtLen -= PlainTxtLen;  
  180.   
  181.     //  control the case that PlainTxt and CipherTxt are the same buffer  
  182.     return CTR_SUCCESS;  
  183. }  
  184.   
  185. /************************************************************************** 
  186. * 
  187. */  
  188. static RET_VAL CBC_EncUpdate(  
  189.         AES_ALG_INFO    *AlgInfo,       //    
  190.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  191.         DWORD       PlainTxtLen,    //  涝仿登绰 乞巩狼 官捞飘 荐  
  192.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  193.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  194. {  
  195.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  196.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  197.   
  198.     //  
  199.     *CipherTxtLen = BufLen + PlainTxtLen;  
  200.   
  201.     //  No one block  
  202.     if( *CipherTxtLen<BlockLen )   
  203.     {  
  204.         memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)PlainTxtLen);  
  205.         AlgInfo->BufLen += PlainTxtLen;  
  206.         *CipherTxtLen = 0;  
  207.         return CTR_SUCCESS;  
  208.     }  
  209.   
  210.     //  control the case that PlainTxt and CipherTxt are the same buffer  
  211.     if( PlainTxt==CipherTxt )  
  212.         return CTR_FATAL_ERROR;  
  213.   
  214.     //  first block  
  215.     memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen));  
  216.     PlainTxt += BlockLen - BufLen;  
  217.     PlainTxtLen -= BlockLen - BufLen;  
  218.   
  219.     //  core part  
  220.     BlockXor(CipherTxt, AlgInfo->ChainVar, AlgInfo->Buffer);  
  221.     AES_Encrypt(ScheduledKey, CipherTxt);  
  222.     CipherTxt += BlockLen;  
  223.     while( PlainTxtLen>=BlockLen )   
  224.     {  
  225.         BlockXor(CipherTxt, CipherTxt-BlockLen, PlainTxt);  
  226.         AES_Encrypt(ScheduledKey, CipherTxt);  
  227.         PlainTxt += BlockLen;  
  228.         CipherTxt += BlockLen;  
  229.         PlainTxtLen -= BlockLen;  
  230.     }  
  231.     BlockCopy(AlgInfo->ChainVar, CipherTxt-BlockLen);  
  232.   
  233.     //  save remained data  
  234.     memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen);  
  235.     AlgInfo->BufLen = PlainTxtLen;  
  236.     *CipherTxtLen -= PlainTxtLen;  
  237.   
  238.     //  
  239.     return CTR_SUCCESS;  
  240. }  
  241.   
  242. /************************************************************************** 
  243. * 
  244. */  
  245. static RET_VAL OFB_EncUpdate(  
  246.         AES_ALG_INFO    *AlgInfo,       //    
  247.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  248.         DWORD       PlainTxtLen,    //  涝仿登绰 乞巩狼 官捞飘 荐  
  249.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  250.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  251. {  
  252.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  253.     DWORD       BlockLen=AES_BLOCK_LEN;  
  254.     DWORD       BufLen=AlgInfo->BufLen;  
  255.   
  256.     //  Check Output Memory Size  
  257.     *CipherTxtLen = BufLen + PlainTxtLen;  
  258.   
  259.     //  No one block  
  260.     if( *CipherTxtLen<BlockLen )   
  261.     {  
  262.         memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)PlainTxtLen);  
  263.         AlgInfo->BufLen += PlainTxtLen;  
  264.         *CipherTxtLen = 0;  
  265.         return CTR_SUCCESS;  
  266.     }  
  267.   
  268.     //  control the case that PlainTxt and CipherTxt are the same buffer  
  269.     if( PlainTxt==CipherTxt )  
  270.         return CTR_FATAL_ERROR;  
  271.   
  272.     //  first block  
  273.     memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen));  
  274.     PlainTxt += BlockLen - BufLen;  
  275.     PlainTxtLen -= BlockLen - BufLen;  
  276.   
  277.     //  core part  
  278.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  279.     BlockXor(CipherTxt, AlgInfo->ChainVar, AlgInfo->Buffer);  
  280.     CipherTxt += BlockLen;  
  281.     while( PlainTxtLen>=BlockLen )   
  282.     {  
  283.         AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  284.         BlockXor(CipherTxt, AlgInfo->ChainVar, PlainTxt);  
  285.         PlainTxt += BlockLen;  
  286.         CipherTxt += BlockLen;  
  287.         PlainTxtLen -= BlockLen;  
  288.     }  
  289.   
  290.     //  save remained data  
  291.     memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen);  
  292.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + PlainTxtLen;  
  293.     *CipherTxtLen -= PlainTxtLen;  
  294.   
  295.     //  
  296.     return CTR_SUCCESS;  
  297. }  
  298.   
  299. /************************************************************************** 
  300. * 
  301. */  
  302. static RET_VAL CFB_EncUpdate(  
  303.         AES_ALG_INFO    *AlgInfo,       //    
  304.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  305.         DWORD       PlainTxtLen,    //  涝仿登绰 乞巩狼 官捞飘 荐  
  306.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  307.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  308. {  
  309.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  310.     DWORD       BlockLen=AES_BLOCK_LEN;  
  311.     DWORD       BufLen=AlgInfo->BufLen;  
  312.   
  313.     //  Check Output Memory Size  
  314.     *CipherTxtLen = BufLen + PlainTxtLen;  
  315.   
  316.     //  No one block  
  317.     if( *CipherTxtLen<BlockLen )   
  318.     {  
  319.         memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)PlainTxtLen);  
  320.         AlgInfo->BufLen += PlainTxtLen;  
  321.         *CipherTxtLen = 0;  
  322.         return CTR_SUCCESS;  
  323.     }  
  324.   
  325.     //  control the case that PlainTxt and CipherTxt are the same buffer  
  326.     if( PlainTxt==CipherTxt )  
  327.         return CTR_FATAL_ERROR;  
  328.   
  329.     //  first block  
  330.     memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen));  
  331.     PlainTxt += BlockLen - BufLen;  
  332.     PlainTxtLen -= BlockLen - BufLen;  
  333.   
  334.     //  core part  
  335.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  336.     BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer);  
  337.     BlockCopy(CipherTxt, AlgInfo->ChainVar);  
  338.     CipherTxt += BlockLen;  
  339.     while( PlainTxtLen>=BlockLen )   
  340.     {  
  341.         AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  342.         BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, PlainTxt);  
  343.         BlockCopy(CipherTxt, AlgInfo->ChainVar);  
  344.         PlainTxt += BlockLen;  
  345.         CipherTxt += BlockLen;  
  346.         PlainTxtLen -= BlockLen;  
  347.     }  
  348.   
  349.     //  save remained data  
  350.     memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen);  
  351.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + PlainTxtLen;  
  352.     *CipherTxtLen -= PlainTxtLen;  
  353.   
  354.     //  
  355.     return CTR_SUCCESS;  
  356. }  
  357.   
  358. /************************************************************************** 
  359. * 
  360. */  
  361. RET_VAL AES_EncUpdate(  
  362.         AES_ALG_INFO    *AlgInfo,  
  363.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  364.         DWORD       PlainTxtLen,    //  涝仿登绰 乞巩狼 官捞飘 荐  
  365.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  366.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  367. {  
  368.     switch( AlgInfo->ModeID )   
  369.     {  
  370.         case AI_ECB :   return ECB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen);  
  371.         case AI_CBC :   return CBC_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen);  
  372.         case AI_OFB :   return OFB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen);  
  373.         case AI_CFB :   return CFB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen);  
  374.         default :       return CTR_FATAL_ERROR;  
  375.     }  
  376. }  
  377.   
  378. /************************************************************************** 
  379. * 
  380. */  
  381. static RET_VAL ECB_EncFinal(  
  382.         AES_ALG_INFO    *AlgInfo,       //    
  383.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  384.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  385. {  
  386.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  387.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  388.     DWORD       PaddByte;  
  389.   
  390.     //  Padding  
  391.     PaddByte = PaddSet(AlgInfo->Buffer, BufLen, BlockLen, AlgInfo->PadType);  
  392.     if( PaddByte>BlockLen )      return PaddByte;  
  393.   
  394.     if( PaddByte==0 )   
  395.     {  
  396.         *CipherTxtLen = 0;  
  397.         return CTR_SUCCESS;  
  398.     }  
  399.   
  400.     //  core part  
  401.     BlockCopy(CipherTxt, AlgInfo->Buffer);  
  402.     AES_Encrypt(ScheduledKey, CipherTxt);  
  403.   
  404.     //  
  405.     *CipherTxtLen = BlockLen;  
  406.   
  407.     //  
  408.     return CTR_SUCCESS;  
  409. }  
  410.   
  411. /************************************************************************** 
  412. * 
  413. */  
  414. static RET_VAL CBC_EncFinal(  
  415.         AES_ALG_INFO    *AlgInfo,  
  416.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  417.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  418. {  
  419.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  420.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  421.     DWORD       PaddByte;  
  422.   
  423.     //  Padding  
  424.     PaddByte = PaddSet(AlgInfo->Buffer, BufLen, BlockLen, AlgInfo->PadType);  
  425.     if( PaddByte>BlockLen )      return PaddByte;  
  426.   
  427.     if( PaddByte==0 )   
  428.     {  
  429.         *CipherTxtLen = 0;  
  430.         return CTR_SUCCESS;  
  431.     }  
  432.   
  433.     //  core part  
  434.     BlockXor(CipherTxt, AlgInfo->Buffer, AlgInfo->ChainVar);  
  435.     AES_Encrypt(ScheduledKey, CipherTxt);  
  436.     BlockCopy(AlgInfo->ChainVar, CipherTxt);  
  437.   
  438.     //  
  439.     *CipherTxtLen = BlockLen;  
  440.   
  441.     //  
  442.     return CTR_SUCCESS;  
  443. }  
  444.   
  445. /************************************************************************** 
  446. * 
  447. */  
  448. static RET_VAL OFB_EncFinal(  
  449.         AES_ALG_INFO    *AlgInfo,  
  450.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  451.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  452. {  
  453.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  454.     DWORD       BlockLen=AES_BLOCK_LEN;  
  455.     DWORD       BufLen=AlgInfo->BufLen;  
  456.     DWORD       i;  
  457.   
  458.     //  Check Output Memory Size  
  459.     *CipherTxtLen = BlockLen;  
  460.   
  461.     //  core part  
  462.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  463.     for( i=0; i<BufLen; i++)  
  464.         CipherTxt[i] = (BYTE) (AlgInfo->Buffer[i] ^ AlgInfo->ChainVar[i]);  
  465.   
  466.     //  
  467.     *CipherTxtLen = BufLen;  
  468.   
  469.     //  
  470.     return CTR_SUCCESS;  
  471. }  
  472.   
  473. /************************************************************************** 
  474. * 
  475. */  
  476. static RET_VAL CFB_EncFinal(  
  477.         AES_ALG_INFO    *AlgInfo,  
  478.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  479.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  480. {  
  481.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  482.     DWORD       BufLen=AlgInfo->BufLen;  
  483.   
  484.     //  Check Output Memory Size  
  485.     *CipherTxtLen = BufLen;  
  486.   
  487.     //  core part  
  488.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  489.     BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer);  
  490.     memcpy(CipherTxt, AlgInfo->ChainVar, BufLen);  
  491.   
  492.     //  
  493.     *CipherTxtLen = BufLen;  
  494.   
  495.     //  
  496.     return CTR_SUCCESS;  
  497. }  
  498.   
  499. /************************************************************************** 
  500. * 
  501. */  
  502. RET_VAL AES_EncFinal(  
  503.         AES_ALG_INFO    *AlgInfo,  
  504.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  505.         DWORD       *CipherTxtLen)  //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  506. {  
  507.     switch( AlgInfo->ModeID )   
  508.     {  
  509.         case AI_ECB :   return ECB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen);  
  510.         case AI_CBC :   return CBC_EncFinal(AlgInfo, CipherTxt, CipherTxtLen);  
  511.         case AI_OFB :   return OFB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen);  
  512.         case AI_CFB :   return CFB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen);  
  513.         default :       return CTR_FATAL_ERROR;  
  514.     }  
  515. }  
  516.   
  517. /************************************************************************** 
  518. * 
  519. */  
  520. RET_VAL AES_DecInit(AES_ALG_INFO *AlgInfo)  
  521. {  
  522.     AlgInfo->BufLen = 0;  
  523.     if( AlgInfo->ModeID!=AI_ECB )  
  524.         memcpy(AlgInfo->ChainVar, AlgInfo->IV, AES_BLOCK_LEN);  
  525.     return CTR_SUCCESS;  
  526. }  
  527.   
  528. /************************************************************************** 
  529. * 
  530. */  
  531. static RET_VAL ECB_DecUpdate(  
  532.         AES_ALG_INFO    *AlgInfo,  
  533.         BYTE        *CipherTxt,     //  涝仿登绰 鞠龋巩狼 pointer  
  534.         DWORD       CipherTxtLen,   //  涝仿登绰 鞠龋巩狼 官捞飘 荐  
  535.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  536.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  537. {  
  538.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  539.     DWORD       BlockLen=AES_BLOCK_LEN;  
  540.     DWORD       BufLen=AlgInfo->BufLen;  
  541.   
  542.     //  
  543.     *PlainTxtLen = BufLen + CipherTxtLen;  
  544.   
  545.     //  No one block  
  546.     if( BufLen+CipherTxtLen <= BlockLen )   
  547.     {  
  548.         memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen);  
  549.         AlgInfo->BufLen += CipherTxtLen;  
  550.         *PlainTxtLen = 0;  
  551.         return CTR_SUCCESS;  
  552.     }  
  553.   
  554.     //  control the case that CipherTxt and PlainTxt are the same buffer  
  555.     if( CipherTxt==PlainTxt )   return CTR_FATAL_ERROR;  
  556.   
  557.     //  first block  
  558.     *PlainTxtLen = BufLen + CipherTxtLen;  
  559.     memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen));  
  560.     CipherTxt += BlockLen - BufLen;  
  561.     CipherTxtLen -= BlockLen - BufLen;  
  562.   
  563.     //  core part  
  564.     BlockCopy(PlainTxt, AlgInfo->Buffer);  
  565.     AES_Decrypt(ScheduledKey, PlainTxt);  
  566.     PlainTxt += BlockLen;  
  567.     while( CipherTxtLen>BlockLen )   
  568.     {  
  569.         BlockCopy(PlainTxt, CipherTxt);  
  570.         AES_Decrypt(ScheduledKey, PlainTxt);  
  571.         CipherTxt += BlockLen;  
  572.         PlainTxt += BlockLen;  
  573.         CipherTxtLen -= BlockLen;  
  574.     }  
  575.   
  576.     //  save remained data  
  577.     memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen);  
  578.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen;  
  579.     *PlainTxtLen -= CipherTxtLen;  
  580.   
  581.     //  
  582.     return CTR_SUCCESS;  
  583. }  
  584.   
  585. /************************************************************************** 
  586. * 
  587. */  
  588. static RET_VAL CBC_DecUpdate(  
  589.         AES_ALG_INFO    *AlgInfo,  
  590.         BYTE        *CipherTxt,     //  涝仿登绰 鞠龋巩狼 pointer  
  591.         DWORD       CipherTxtLen,   //  涝仿登绰 鞠龋巩狼 官捞飘 荐  
  592.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  593.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  594. {  
  595.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  596.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  597.   
  598.     //  Check Output Memory Size  
  599.     *PlainTxtLen = BufLen + CipherTxtLen;  
  600.   
  601.     //  No one block  
  602.     if( BufLen+CipherTxtLen <= BlockLen )   
  603.     {  
  604.         memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen);  
  605.         AlgInfo->BufLen += CipherTxtLen;  
  606.         *PlainTxtLen = 0;  
  607.         return CTR_SUCCESS;  
  608.     }  
  609.   
  610.     //  control the case that CipherTxt and PlainTxt are the same buffer  
  611.     if( CipherTxt==PlainTxt )   return CTR_FATAL_ERROR;  
  612.   
  613.     //  first block  
  614.     *PlainTxtLen = BufLen + CipherTxtLen;  
  615.     memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen));  
  616.     CipherTxt += BlockLen - BufLen;  
  617.     CipherTxtLen -= BlockLen - BufLen;  
  618.   
  619.     //  core part  
  620.     BlockCopy(PlainTxt, AlgInfo->Buffer);  
  621.     AES_Decrypt(ScheduledKey, PlainTxt);  
  622.     BlockXor(PlainTxt, PlainTxt, AlgInfo->ChainVar);  
  623.     PlainTxt += BlockLen;  
  624.     if( CipherTxtLen<=BlockLen )   
  625.     {  
  626.         BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer);  
  627.     }  
  628.     else   
  629.     {  
  630.         if( CipherTxtLen>BlockLen )   
  631.         {  
  632.             BlockCopy(PlainTxt, CipherTxt);  
  633.             AES_Decrypt(ScheduledKey, PlainTxt);  
  634.             BlockXor(PlainTxt, PlainTxt, AlgInfo->Buffer);  
  635.             CipherTxt += BlockLen;  
  636.             PlainTxt += BlockLen;  
  637.             CipherTxtLen -= BlockLen;  
  638.         }  
  639.         while( CipherTxtLen>BlockLen )   
  640.         {  
  641.             BlockCopy(PlainTxt, CipherTxt);  
  642.             AES_Decrypt(ScheduledKey, PlainTxt);  
  643.             BlockXor(PlainTxt, PlainTxt, CipherTxt-BlockLen);  
  644.             CipherTxt += BlockLen;  
  645.             PlainTxt += BlockLen;  
  646.             CipherTxtLen -= BlockLen;  
  647.         }  
  648.         BlockCopy(AlgInfo->ChainVar, CipherTxt-BlockLen);  
  649.     }  
  650.   
  651.     //  save remained data  
  652.     memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen);  
  653.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen;  
  654.     *PlainTxtLen -= CipherTxtLen;  
  655.   
  656.     //  
  657.     return CTR_SUCCESS;  
  658. }  
  659.   
  660. /************************************************************************** 
  661. * 
  662. */  
  663. static RET_VAL OFB_DecUpdate(  
  664.         AES_ALG_INFO    *AlgInfo,  
  665.         BYTE        *CipherTxt,     //  涝仿登绰 鞠龋巩狼 pointer  
  666.         DWORD       CipherTxtLen,   //  涝仿登绰 鞠龋巩狼 官捞飘 荐  
  667.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  668.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  669. {  
  670.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  671.     DWORD       BlockLen=AES_BLOCK_LEN;  
  672.     DWORD       BufLen=AlgInfo->BufLen;  
  673.   
  674.     //  Check Output Memory Size  
  675.     *PlainTxtLen = BufLen + CipherTxtLen;  
  676.   
  677.     //  No one block  
  678.     if( BufLen+CipherTxtLen <= BlockLen )  
  679.     {  
  680.         memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen);  
  681.         AlgInfo->BufLen += CipherTxtLen;  
  682.         *PlainTxtLen = 0;  
  683.         return CTR_SUCCESS;  
  684.     }  
  685.   
  686.     //  control the case that CipherTxt and PlainTxt are the same buffer  
  687.     if( PlainTxt==CipherTxt )  
  688.         return CTR_FATAL_ERROR;  
  689.   
  690.     //  first block  
  691.     *PlainTxtLen = BufLen + CipherTxtLen;  
  692.     memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen));  
  693.     CipherTxt += BlockLen - BufLen;  
  694.     CipherTxtLen -= BlockLen - BufLen;  
  695.   
  696.     //  core part  
  697.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  698.     BlockXor(PlainTxt, AlgInfo->ChainVar, AlgInfo->Buffer);  
  699.     PlainTxt += BlockLen;  
  700.     while( CipherTxtLen>BlockLen )   
  701.     {  
  702.         AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  703.         BlockXor(PlainTxt, AlgInfo->ChainVar, CipherTxt);  
  704.         CipherTxt += BlockLen;  
  705.         PlainTxt += BlockLen;  
  706.         CipherTxtLen -= BlockLen;  
  707.     }  
  708.   
  709.     //  save remained data  
  710.     memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen);  
  711.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen;  
  712.     *PlainTxtLen -= CipherTxtLen;  
  713.   
  714.     //  
  715.     return CTR_SUCCESS;  
  716. }  
  717.   
  718. /************************************************************************** 
  719. * 
  720. */  
  721. static RET_VAL CFB_DecUpdate(  
  722.         AES_ALG_INFO    *AlgInfo,  
  723.         BYTE        *CipherTxt,     //  涝仿登绰 鞠龋巩狼 pointer  
  724.         DWORD       CipherTxtLen,   //  涝仿登绰 鞠龋巩狼 官捞飘 荐  
  725.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  726.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  727. {  
  728.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  729.     DWORD       BlockLen=AES_BLOCK_LEN;  
  730.     DWORD       BufLen=AlgInfo->BufLen;  
  731.   
  732.     //  Check Output Memory Size  
  733.     *PlainTxtLen = BufLen + CipherTxtLen;  
  734.   
  735.     //  No one block  
  736.     if( BufLen+CipherTxtLen <= BlockLen )   
  737.     {  
  738.         memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen);  
  739.         AlgInfo->BufLen += CipherTxtLen;  
  740.         *PlainTxtLen = 0;  
  741.         return CTR_SUCCESS;  
  742.     }  
  743.   
  744.     //  control the case that CipherTxt and PlainTxt are the same buffer  
  745.     if( PlainTxt==CipherTxt )  
  746.         return CTR_FATAL_ERROR;  
  747.   
  748.     //  first block  
  749.     *PlainTxtLen = BufLen + CipherTxtLen;  
  750.     memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen));  
  751.     CipherTxt += BlockLen - BufLen;  
  752.     CipherTxtLen -= BlockLen - BufLen;  
  753.   
  754.     //  core part  
  755.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  756.     BlockXor(PlainTxt, AlgInfo->ChainVar, AlgInfo->Buffer);  
  757.     BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer);  
  758.     PlainTxt += BlockLen;  
  759.     while( CipherTxtLen>BlockLen )   
  760.     {  
  761.         AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  762.         BlockXor(PlainTxt, AlgInfo->ChainVar, CipherTxt);  
  763.         BlockCopy(AlgInfo->ChainVar, CipherTxt);  
  764.         CipherTxt += BlockLen;  
  765.         PlainTxt += BlockLen;  
  766.         CipherTxtLen -= BlockLen;  
  767.     }  
  768.   
  769.     //  save remained data  
  770.     memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen);  
  771.     AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen;  
  772.     *PlainTxtLen -= CipherTxtLen;  
  773.   
  774.     //  
  775.     return CTR_SUCCESS;  
  776. }  
  777.   
  778. /************************************************************************** 
  779. * 
  780. */  
  781. RET_VAL AES_DecUpdate(  
  782.         AES_ALG_INFO    *AlgInfo,  
  783.         BYTE        *CipherTxt,     //  鞠龋巩捞 免仿瞪 pointer  
  784.         DWORD       CipherTxtLen,   //  免仿登绰 鞠龋巩狼 官捞飘 荐  
  785.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  786.         DWORD       *PlainTxtLen)   //  涝仿登绰 乞巩狼 官捞飘 荐  
  787. {  
  788.     switch( AlgInfo->ModeID )   
  789.     {  
  790.         case AI_ECB :   return ECB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen);  
  791.         case AI_CBC :   return CBC_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen);  
  792.         case AI_OFB :   return OFB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen);  
  793.         case AI_CFB :   return CFB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen);  
  794.         default :       return CTR_FATAL_ERROR;  
  795.     }  
  796. }  
  797.   
  798. /************************************************************************** 
  799. * 
  800. */  
  801. RET_VAL ECB_DecFinal(  
  802.         AES_ALG_INFO    *AlgInfo,  
  803.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  804.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  805. {  
  806.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  807.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  808.     RET_VAL     ret;  
  809.   
  810.     //  Check Output Memory Size  
  811.     if( BufLen==0 )   
  812.     {  
  813.         *PlainTxtLen = 0;  
  814.         return CTR_SUCCESS;  
  815.     }  
  816.     *PlainTxtLen = BlockLen;  
  817.   
  818.     if( BufLen!=BlockLen )  return CTR_CIPHER_LEN_ERROR;  
  819.   
  820.     //  core part  
  821.     BlockCopy(PlainTxt, AlgInfo->Buffer);  
  822.     AES_Decrypt(ScheduledKey, PlainTxt);  
  823.   
  824.     //  Padding Check  
  825.     ret = PaddCheck(PlainTxt, BlockLen, AlgInfo->PadType);  
  826.     if( ret==(DWORD)-3 )    return CTR_PAD_CHECK_ERROR;  
  827.     if( ret==(DWORD)-1 )    return CTR_FATAL_ERROR;  
  828.   
  829.     *PlainTxtLen = BlockLen - ret;  
  830.   
  831.     //  
  832.     return CTR_SUCCESS;  
  833. }  
  834.   
  835. /************************************************************************** 
  836. * 
  837. */  
  838. RET_VAL CBC_DecFinal(  
  839.         AES_ALG_INFO    *AlgInfo,  
  840.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  841.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  842. {  
  843.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  844.     DWORD       BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen;  
  845.     RET_VAL     ret;  
  846.   
  847.     //  Check Output Memory Size  
  848.     if( BufLen==0 )   
  849.     {  
  850.         *PlainTxtLen = 0;  
  851.         return CTR_SUCCESS;  
  852.     }  
  853.     *PlainTxtLen = BlockLen;  
  854.   
  855.     if( BufLen!=BlockLen )  return CTR_CIPHER_LEN_ERROR;  
  856.   
  857.     //  core part  
  858.     BlockCopy(PlainTxt, AlgInfo->Buffer);  
  859.     AES_Decrypt(ScheduledKey, PlainTxt);  
  860.     BlockXor(PlainTxt, PlainTxt, AlgInfo->ChainVar);  
  861.     BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer);  
  862.   
  863.     //  Padding Check  
  864.     ret = PaddCheck(PlainTxt, BlockLen, AlgInfo->PadType);  
  865.     if( ret==(DWORD)-3 )    return CTR_PAD_CHECK_ERROR;  
  866.     if( ret==(DWORD)-1 )    return CTR_FATAL_ERROR;  
  867.   
  868.     *PlainTxtLen = BlockLen - ret;  
  869.   
  870.     //  
  871.     return CTR_SUCCESS;  
  872. }  
  873.   
  874. /************************************************************************** 
  875. * 
  876. */  
  877. RET_VAL OFB_DecFinal(  
  878.         AES_ALG_INFO    *AlgInfo,  
  879.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  880.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  881. {  
  882.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  883.     DWORD       i, BufLen=AlgInfo->BufLen;  
  884.   
  885.     //  Check Output Memory Size  
  886.     *PlainTxtLen = BufLen;  
  887.   
  888.     //  core part  
  889.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  890.     for( i=0; i<BufLen; i++)  
  891.         PlainTxt[i] = (BYTE) (AlgInfo->Buffer[i] ^ AlgInfo->ChainVar[i]);  
  892.   
  893.     *PlainTxtLen = BufLen;  
  894.   
  895.     //  
  896.     return CTR_SUCCESS;  
  897. }  
  898.   
  899.   
  900. /************************************************************************** 
  901. * 
  902. */  
  903. RET_VAL CFB_DecFinal(  
  904.         AES_ALG_INFO    *AlgInfo,  
  905.         BYTE        *PlainTxt,      //  乞巩捞 免仿瞪 pointer  
  906.         DWORD       *PlainTxtLen)   //  免仿登绰 乞巩狼 官捞飘 荐  
  907. {  
  908.     DWORD       *ScheduledKey=AlgInfo->RoundKey;  
  909.     DWORD       BufLen=AlgInfo->BufLen;  
  910.   
  911.     //  Check Output Memory Size  
  912.     *PlainTxtLen = BufLen;  
  913.   
  914.     //  core part  
  915.     AES_Encrypt(ScheduledKey, AlgInfo->ChainVar);  
  916.     BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer);  
  917.     memcpy(PlainTxt, AlgInfo->ChainVar, BufLen);  
  918.   
  919.     *PlainTxtLen = BufLen;  
  920.   
  921.     //  
  922.     return CTR_SUCCESS;  
  923. }  
  924.   
  925. /************************************************************************** 
  926. * 
  927. */  
  928. RET_VAL AES_DecFinal(  
  929.         AES_ALG_INFO    *AlgInfo,  
  930.         BYTE        *PlainTxt,      //  涝仿登绰 乞巩狼 pointer  
  931.         DWORD       *PlainTxtLen)   //  涝仿登绰 乞巩狼 官捞飘 荐  
  932. {  
  933.     switch( AlgInfo->ModeID )   
  934.     {  
  935.         case AI_ECB :   return ECB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen);  
  936.         case AI_CBC :   return CBC_DecFinal(AlgInfo, PlainTxt, PlainTxtLen);  
  937.         case AI_OFB :   return OFB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen);  
  938.         case AI_CFB :   return CFB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen);  
  939.         default :       return CTR_FATAL_ERROR;  
  940.     }  
  941. }  
  942.   
  943. /*************** END OF FILE **********************************************/  

 

 

AES.C文件

 

 

[cpp] view plain copy print ?
  1. /*************** Header files *********************************************/  
  2. #include "aes.h"  
  3.   
  4. /*************** Assertions ***********************************************/  
  5.   
  6. /*************** New Data Types *******************************************/  
  7. typedef struct {  
  8.     DWORD   k_len;  
  9.     DWORD   RK[64];  
  10. } RIJNDAEL_CIPHER_KEY;  
  11.   
  12. /*************** Definitions / Macros  ************************************/  
  13. #define u1byte  BYTE  
  14. #define u4byte  DWORD  
  15. #define rotl    ROTL_DWORD  
  16. #define rotr    ROTR_DWORD  
  17. #define byte(x,n)   ((u1byte)((x) >> (8 * n)))  
  18.   
  19. #define LARGE_TABLES  
  20.   
  21. #define ff_mult(a,b)    (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0)  
  22.   
  23. #ifdef LARGE_TABLES  
  24.     #define ls_box(x)                /  
  25.         ( fl_tab[0][byte(x, 0)] ^    /  
  26.           fl_tab[1][byte(x, 1)] ^    /  
  27.           fl_tab[2][byte(x, 2)] ^    /  
  28.           fl_tab[3][byte(x, 3)] )  
  29. #else  
  30.     #define ls_box(x)                            /  
  31.         ((u4byte)sbx_tab[byte(x, 0)] <<  0) ^  /  
  32.         ((u4byte)sbx_tab[byte(x, 1)] <<  8) ^  /  
  33.         ((u4byte)sbx_tab[byte(x, 2)] << 16) ^  /  
  34.         ((u4byte)sbx_tab[byte(x, 3)] << 24)  
  35. #endif  
  36.   
  37. /*************** Global Variables *****************************************/  
  38. static u1byte   log_tab[256];  
  39. static u1byte   pow_tab[256];  
  40. static u1byte   sbx_tab[256];  
  41. static u1byte   isb_tab[256];  
  42. static u4byte   rco_tab[ 10];  
  43. static u4byte   ft_tab[4][256];  
  44. static u4byte   it_tab[4][256];  
  45.   
  46. #ifdef  LARGE_TABLES  
  47.   static u4byte  fl_tab[4][256];  
  48.   static u4byte  il_tab[4][256];  
  49. #endif  
  50.   
  51. static u4byte   tab_gen = 0;  
  52.   
  53.   
  54. /*************** Prototypes ***********************************************/  
  55. static void gen_tabs(void)  
  56. {  
  57.     u4byte  i, t;  
  58.     u1byte  p, q;  
  59.   
  60.     /* log and power tables for GF(2**8) finite field with  */  
  61.     /* 0x11b as modular polynomial - the simplest prmitive  */  
  62.     /* root is 0x11, used here to generate the tables       */  
  63.   
  64.     log_tab[7] = 0;  
  65.     for(i = 0,p = 1; i < 256; ++i)  
  66.     {  
  67.         pow_tab[i] = (BYTE)p;  
  68.         log_tab[p] = (BYTE)i;  
  69.   
  70.         p = (BYTE)(p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0));  
  71.     }  
  72.   
  73.     log_tab[1] = 0;  
  74.     p = 1;  
  75.   
  76.     for(i = 0; i < 10; ++i)  
  77.     {  
  78.         rco_tab[i] = p;   
  79.   
  80.         p = (BYTE)((p << 1) ^ (p & 0x80 ? 0x1b : 0));  
  81.     }  
  82.   
  83.     /* note that the affine byte transformation matrix in   */  
  84.     /* rijndael specification is in big endian format with  */  
  85.     /* bit 0 as the most significant bit. In the remainder  */  
  86.     /* of the specification the bits are numbered from the  */  
  87.     /* least significant end of a byte.                     */  
  88.   
  89.     for(i = 0; i < 256; ++i)  
  90.     {     
  91.         p = (BYTE)(i ? pow_tab[255 - log_tab[i]] : 0);  
  92.         q = p;  
  93.         q = (BYTE)((q >> 7) | (q << 1));  
  94.         p ^= q;  
  95.         q = (BYTE)((q >> 7) | (q << 1));  
  96.         p ^= q;  
  97.         q = (BYTE)((q >> 7) | (q << 1));  
  98.         p ^= q;  
  99.         q = (BYTE)((q >> 7) | (q << 1));  
  100.         p ^= q ^ 0x63;  
  101.         sbx_tab[i] = (u1byte)p;  
  102.         isb_tab[p] = (u1byte)i;  
  103.     }  
  104.   
  105.     for(i = 0; i < 256; ++i)  
  106.     {  
  107.         p = sbx_tab[i];   
  108.   
  109. #ifdef  LARGE_TABLES  
  110.         t = p;  
  111.         fl_tab[0][i] = t;  
  112.         fl_tab[1][i] = rotl(t,  8);  
  113.         fl_tab[2][i] = rotl(t, 16);  
  114.         fl_tab[3][i] = rotl(t, 24);  
  115. #endif  
  116.         t = ((u4byte)ff_mult(2, p)) |  
  117.             ((u4byte)p <<  8) |  
  118.             ((u4byte)p << 16) |  
  119.             ((u4byte)ff_mult(3, p) << 24);  
  120.           
  121.         ft_tab[0][i] = t;  
  122.         ft_tab[1][i] = rotl(t,  8);  
  123.         ft_tab[2][i] = rotl(t, 16);  
  124.         ft_tab[3][i] = rotl(t, 24);  
  125.   
  126.         p = isb_tab[i];   
  127.   
  128. #ifdef  LARGE_TABLES  
  129.         t = p; il_tab[0][i] = t;   
  130.         il_tab[1][i] = rotl(t,  8);   
  131.         il_tab[2][i] = rotl(t, 16);   
  132.         il_tab[3][i] = rotl(t, 24);  
  133. #endif   
  134.         t = ((u4byte)ff_mult(14, p)) |  
  135.             ((u4byte)ff_mult( 9, p) <<    8) |  
  136.             ((u4byte)ff_mult(13, p) << 16) |  
  137.             ((u4byte)ff_mult(11, p) << 24);  
  138.           
  139.         it_tab[0][i] = t;   
  140.         it_tab[1][i] = rotl(t,  8);   
  141.         it_tab[2][i] = rotl(t, 16);   
  142.         it_tab[3][i] = rotl(t, 24);   
  143.     }  
  144.   
  145.     tab_gen = 1;  
  146. };  
  147.   
  148. #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b)  
  149.   
  150. #define imix_col(y,x)       /  
  151.      u  = star_x(x);        /  
  152.      v  = star_x(u);        /  
  153.      w  = star_x(v);        /  
  154.      t  = w ^ (x);          /  
  155.     (y) = u ^ v ^ w;        /  
  156.     (y) ^= rotr(u ^ t,  8) ^ /  
  157.           rotr(v ^ t, 16) ^ /  
  158.           rotr(t,24)  
  159.   
  160. /************************************************************************** 
  161. * 
  162. *   Function Description ... 
  163. *    
  164. *   Return values: 
  165. *       - CTR_SUCCESS                       窃荐啊 己傍利栏肺 荐青凳. 
  166. *       ... 
  167. */  
  168. static void RIJNDAEL_KeySchedule(  
  169.         BYTE        *UserKey,       //  荤侩磊 厚剐虐 涝仿  
  170.         DWORD       k_len,          //  荤侩磊 厚剐虐狼 DWORD 荐  
  171.         DWORD       *e_key)         //  鞠龋侩 Round Key 积己/免仿  
  172. {  
  173.     u4byte  i, t;  
  174.   
  175.       
  176.     if(!tab_gen)  
  177.         gen_tabs();  
  178.   
  179.     LITTLE_B2D(&(UserKey[ 0]), e_key[0]);  
  180.     LITTLE_B2D(&(UserKey[ 4]), e_key[1]);  
  181.     LITTLE_B2D(&(UserKey[ 8]), e_key[2]);  
  182.     LITTLE_B2D(&(UserKey[12]), e_key[3]);  
  183.   
  184.     switch(k_len)  
  185.     {  
  186.         case 4:  
  187.                 t = e_key[3];  
  188.                 for(i = 0; i < 10; ++i) {  
  189.                     t = ls_box(rotr(t,  8)) ^ rco_tab[i];  
  190.                     t ^= e_key[4 * i];     e_key[4 * i + 4] = t;  
  191.                     t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t;  
  192.                     t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t;  
  193.                     t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t;  
  194.                 }  
  195.                 break;  
  196.   
  197.         case 6:  
  198.                 LITTLE_B2D(&(UserKey[16]), e_key[4]);  
  199.                 LITTLE_B2D(&(UserKey[20]), e_key[5]);  
  200.                 t = e_key[5];  
  201.                 for(i = 0; i < 8; ++i) {  
  202.                     t = ls_box(rotr(t,  8)) ^ rco_tab[i];  
  203.                     t ^= e_key[6 * i];     e_key[6 * i + 6] = t;  
  204.                     t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t;  
  205.                     t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t;  
  206.                     t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t;  
  207.                     t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t;  
  208.                     t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t;  
  209.                 }  
  210. //                  loop6(i);  
  211.                 break;  
  212.   
  213.         case 8:  
  214.                 LITTLE_B2D(&(UserKey[16]), e_key[4]);  
  215.                 LITTLE_B2D(&(UserKey[20]), e_key[5]);  
  216.                 LITTLE_B2D(&(UserKey[24]), e_key[6]);  
  217.                 LITTLE_B2D(&(UserKey[28]), e_key[7]);  
  218.                 t = e_key[7];  
  219.                 for(i = 0; i < 7; ++i) {  
  220.                     t = ls_box(rotr(t,  8)) ^ rco_tab[i];  
  221.                     t ^= e_key[8 * i];     e_key[8 * i + 8] = t;  
  222.                     t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t;  
  223.                     t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t;  
  224.                     t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t;  
  225.                     t  = e_key[8 * i + 4] ^ ls_box(t);  
  226.                     e_key[8 * i + 12] = t;  
  227.                     t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t;  
  228.                     t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t;  
  229.                     t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t;  
  230.                 }  
  231. //                  loop8(i);  
  232.                 break;  
  233.     }  
  234. }  
  235.   
  236. /*************** Function ************************************************* 
  237. *  
  238. */  
  239. RET_VAL AES_EncKeySchedule(  
  240.         BYTE        *UserKey,       //  荤侩磊 厚剐虐 涝仿  
  241.         DWORD       UserKeyLen,     //  荤侩磊 厚剐虐狼 官捞飘 荐  
  242.         AES_ALG_INFO    *AlgInfo)   //  鞠龋侩/汗龋侩 Round Key 积己/历厘  
  243. {  
  244.     RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey;  
  245.     DWORD   *e_key=RK_Struct->RK;    //  64 DWORDs  
  246.     DWORD   k_len;  
  247.   
  248.     //  UserKey狼 辨捞啊 何利例茄 版快 error 贸府  
  249.     if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) )  
  250.         return CTR_INVALID_USERKEYLEN;  
  251.   
  252.       
  253.     k_len = (UserKeyLen + 3) / 4;  
  254.     RK_Struct->k_len = k_len;  
  255.   
  256.     RIJNDAEL_KeySchedule(UserKey, k_len, e_key);  
  257.   
  258.     return CTR_SUCCESS;  
  259. }  
  260.   
  261. /*************** Function ************************************************* 
  262. *  
  263. */  
  264. RET_VAL AES_DecKeySchedule(  
  265.         BYTE        *UserKey,       //  荤侩磊 厚剐虐 涝仿  
  266.         DWORD       UserKeyLen,     //  荤侩磊 厚剐虐狼 官捞飘 荐  
  267.         AES_ALG_INFO    *AlgInfo)   //  鞠龋侩/汗龋侩 Round Key 积己/历厘  
  268. {  
  269.     RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey;  
  270.     DWORD   *d_key=RK_Struct->RK;    //  64 DWORDs  
  271.     DWORD   k_len, t_key[64];  
  272.     u4byte  i, t, u, v, w;  
  273.   
  274.     //  UserKey狼 辨捞啊 何利例茄 版快 error 贸府  
  275.     if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) )  
  276.         return CTR_INVALID_USERKEYLEN;  
  277.   
  278.       
  279.     k_len = (UserKeyLen + 3) / 4;  
  280.     RK_Struct->k_len = k_len;  
  281.   
  282.     RIJNDAEL_KeySchedule(UserKey, k_len, t_key);  
  283.   
  284.     d_key[0] = t_key[4 * k_len + 24];  
  285.     d_key[1] = t_key[4 * k_len + 25];  
  286.     d_key[2] = t_key[4 * k_len + 26];  
  287.     d_key[3] = t_key[4 * k_len + 27];  
  288.   
  289.     for( i=4; i<4*(k_len+6); i+=4) {  
  290.         imix_col(d_key[i+0], t_key[4*k_len+24-i+0]);  
  291.         imix_col(d_key[i+1], t_key[4*k_len+24-i+1]);  
  292.         imix_col(d_key[i+2], t_key[4*k_len+24-i+2]);  
  293.         imix_col(d_key[i+3], t_key[4*k_len+24-i+3]);  
  294.     }  
  295.     d_key[i+0] = t_key[4*k_len+24-i+0];  
  296.     d_key[i+1] = t_key[4*k_len+24-i+1];  
  297.     d_key[i+2] = t_key[4*k_len+24-i+2];  
  298.     d_key[i+3] = t_key[4*k_len+24-i+3];  
  299.   
  300.     return CTR_SUCCESS;  
  301. }  
  302.   
  303. /* 
  304.     DWORD   A, B, C, D, T0, T1, *K=AlgInfo->RoundKey; 
  305.  
  306.      
  307.     if( UserKeyLen!=SEED_USER_KEY_LEN ) 
  308.         return CTR_INVALID_USERKEYLEN; 
  309.  
  310.      
  311.     BIG_B2D( &(UserKey[0]), A); 
  312.     BIG_B2D( &(UserKey[4]), B); 
  313.     BIG_B2D( &(UserKey[8]), C); 
  314.     BIG_B2D( &(UserKey[12]), D); 
  315.  
  316.     T0 = A + C - KC0; 
  317.     T1 = B - D + KC0; 
  318.     K[0] = SEED_SL[0][(T0    )&0xFF] ^ SEED_SL[1][(T0>> 8)&0xFF] 
  319.          ^ SEED_SL[2][(T0>>16)&0xFF] ^ SEED_SL[3][(T0>>24)&0xFF]; 
  320.     K[1] = SEED_SL[0][(T1    )&0xFF] ^ SEED_SL[1][(T1>> 8)&0xFF] 
  321.          ^ SEED_SL[2][(T1>>16)&0xFF] ^ SEED_SL[3][(T1>>24)&0xFF];; 
  322.  
  323.     EncRoundKeyUpdate0(K+ 2, A, B, C, D, KC1 ); 
  324.     EncRoundKeyUpdate1(K+ 4, A, B, C, D, KC2 ); 
  325.     EncRoundKeyUpdate0(K+ 6, A, B, C, D, KC3 ); 
  326.     EncRoundKeyUpdate1(K+ 8, A, B, C, D, KC4 ); 
  327.     EncRoundKeyUpdate0(K+10, A, B, C, D, KC5 ); 
  328.     EncRoundKeyUpdate1(K+12, A, B, C, D, KC6 ); 
  329.     EncRoundKeyUpdate0(K+14, A, B, C, D, KC7 ); 
  330.     EncRoundKeyUpdate1(K+16, A, B, C, D, KC8 ); 
  331.     EncRoundKeyUpdate0(K+18, A, B, C, D, KC9 ); 
  332.     EncRoundKeyUpdate1(K+20, A, B, C, D, KC10); 
  333.     EncRoundKeyUpdate0(K+22, A, B, C, D, KC11); 
  334.     EncRoundKeyUpdate1(K+24, A, B, C, D, KC12); 
  335.     EncRoundKeyUpdate0(K+26, A, B, C, D, KC13); 
  336.     EncRoundKeyUpdate1(K+28, A, B, C, D, KC14); 
  337.     EncRoundKeyUpdate0(K+30, A, B, C, D, KC15); 
  338.  
  339.     //  Remove sensitive data 
  340.     A = B = C = D = T0 = T1 = 0; 
  341.     K = NULL; 
  342.  
  343.     // 
  344.     return CTR_SUCCESS; 
  345. */  
  346.   
  347. /*************** Macros ***************************************************/  
  348. #define f_nround(bo, bi, k) {               /  
  349.     bo[0] = ft_tab[0][byte(bi[0],0)]        /  
  350.           ^ ft_tab[1][byte(bi[1],1)]        /  
  351.           ^ ft_tab[2][byte(bi[2],2)]        /  
  352.           ^ ft_tab[3][byte(bi[3],3)] ^ k[0];/  
  353.     bo[1] = ft_tab[0][byte(bi[1],0)]        /  
  354.           ^ ft_tab[1][byte(bi[2],1)]        /  
  355.           ^ ft_tab[2][byte(bi[3],2)]        /  
  356.           ^ ft_tab[3][byte(bi[0],3)] ^ k[1];/  
  357.     bo[2] = ft_tab[0][byte(bi[2],0)]        /  
  358.           ^ ft_tab[1][byte(bi[3],1)]        /  
  359.           ^ ft_tab[2][byte(bi[0],2)]        /  
  360.           ^ ft_tab[3][byte(bi[1],3)] ^ k[2];/  
  361.     bo[3] = ft_tab[0][byte(bi[3],0)]        /  
  362.           ^ ft_tab[1][byte(bi[0],1)]        /  
  363.           ^ ft_tab[2][byte(bi[1],2)]        /  
  364.           ^ ft_tab[3][byte(bi[2],3)] ^ k[3];/  
  365.     k += 4;                                 /  
  366. }  
  367.   
  368. #define i_nround(bo, bi, k) {               /  
  369.     bo[0] = it_tab[0][byte(bi[0],0)]        /  
  370.           ^ it_tab[1][byte(bi[3],1)]        /  
  371.           ^ it_tab[2][byte(bi[2],2)]        /  
  372.           ^ it_tab[3][byte(bi[1],3)] ^ k[0];/  
  373.     bo[1] = it_tab[0][byte(bi[1],0)]        /  
  374.           ^ it_tab[1][byte(bi[0],1)]        /  
  375.           ^ it_tab[2][byte(bi[3],2)]        /  
  376.           ^ it_tab[3][byte(bi[2],3)] ^ k[1];/  
  377.     bo[2] = it_tab[0][byte(bi[2],0)]        /  
  378.           ^ it_tab[1][byte(bi[1],1)]        /  
  379.           ^ it_tab[2][byte(bi[0],2)]        /  
  380.           ^ it_tab[3][byte(bi[3],3)] ^ k[2];/  
  381.     bo[3] = it_tab[0][byte(bi[3],0)]        /  
  382.           ^ it_tab[1][byte(bi[2],1)]        /  
  383.           ^ it_tab[2][byte(bi[1],2)]        /  
  384.           ^ it_tab[3][byte(bi[0],3)] ^ k[3];/  
  385.     k += 4;                 /  
  386. }  
  387.   
  388. #ifdef LARGE_TABLES  
  389.     #define f_lround(bo, bi, k) {               /  
  390.         bo[0] = fl_tab[0][byte(bi[0],0)]        /  
  391.               ^ fl_tab[1][byte(bi[1],1)]        /  
  392.               ^ fl_tab[2][byte(bi[2],2)]        /  
  393.               ^ fl_tab[3][byte(bi[3],3)] ^ k[0];/  
  394.         bo[1] = fl_tab[0][byte(bi[1],0)]        /  
  395.               ^ fl_tab[1][byte(bi[2],1)]        /  
  396.               ^ fl_tab[2][byte(bi[3],2)]        /  
  397.               ^ fl_tab[3][byte(bi[0],3)] ^ k[1];/  
  398.         bo[2] = fl_tab[0][byte(bi[2],0)]        /  
  399.               ^ fl_tab[1][byte(bi[3],1)]        /  
  400.               ^ fl_tab[2][byte(bi[0],2)]        /  
  401.               ^ fl_tab[3][byte(bi[1],3)] ^ k[2];/  
  402.         bo[3] = fl_tab[0][byte(bi[3],0)]        /  
  403.               ^ fl_tab[1][byte(bi[0],1)]        /  
  404.               ^ fl_tab[2][byte(bi[1],2)]        /  
  405.               ^ fl_tab[3][byte(bi[2],3)] ^ k[3];/  
  406.     }  
  407.   
  408.     #define i_lround(bo, bi, k) {               /  
  409.         bo[0] = il_tab[0][byte(bi[0],0)]        /  
  410.               ^ il_tab[1][byte(bi[3],1)]        /  
  411.               ^ il_tab[2][byte(bi[2],2)]        /  
  412.               ^ il_tab[3][byte(bi[1],3)] ^ k[0];/  
  413.         bo[1] = il_tab[0][byte(bi[1],0)]        /  
  414.               ^ il_tab[1][byte(bi[0],1)]        /  
  415.               ^ il_tab[2][byte(bi[3],2)]        /  
  416.               ^ il_tab[3][byte(bi[2],3)] ^ k[1];/  
  417.         bo[2] = il_tab[0][byte(bi[2],0)]        /  
  418.               ^ il_tab[1][byte(bi[1],1)]        /  
  419.               ^ il_tab[2][byte(bi[0],2)]        /  
  420.               ^ il_tab[3][byte(bi[3],3)] ^ k[2];/  
  421.         bo[3] = il_tab[0][byte(bi[3],0)]        /  
  422.               ^ il_tab[1][byte(bi[2],1)]        /  
  423.               ^ il_tab[2][byte(bi[1],2)]        /  
  424.               ^ il_tab[3][byte(bi[0],3)] ^ k[3];/  
  425.         }  
  426. #else  
  427.     #define f_rl(bo, bi, n, k)                                      /  
  428.         bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^                    /  
  429.             rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]),  8) ^  /  
  430.             rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^  /  
  431.             rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n)  
  432.   
  433.     #define i_rl(bo, bi, n, k)                                      /  
  434.         bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^                    /  
  435.             rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]),  8) ^  /  
  436.             rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^  /  
  437.             rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n)  
  438.   
  439.     #define f_lround(bo, bi, k) /  
  440.         f_rl(bo, bi, 0, k);     /  
  441.         f_rl(bo, bi, 1, k);     /  
  442.         f_rl(bo, bi, 2, k);     /  
  443.         f_rl(bo, bi, 3, k)  
  444.   
  445.     #define i_lround(bo, bi, k) /  
  446.         i_rl(bo, bi, 0, k);     /  
  447.         i_rl(bo, bi, 1, k);     /  
  448.         i_rl(bo, bi, 2, k);     /  
  449.         i_rl(bo, bi, 3, k)  
  450. #endif  
  451.   
  452. /*************** Function ************************************************* 
  453. *    
  454. */  
  455. void    AES_Encrypt(  
  456.         void        *CipherKey,     //  鞠/汗龋侩 Round Key  
  457.         BYTE        *Data)          //  涝免仿阑 困茄 喉废阑 啊府虐绰 pointer  
  458. {  
  459.     RIJNDAEL_CIPHER_KEY *RK_Struct=CipherKey;  
  460.     DWORD   *e_key=RK_Struct->RK;    //  64 DWORDs  
  461.     DWORD   k_len=RK_Struct->k_len;  
  462.     u4byte  b0[4], b1[4], *kp;  
  463.   
  464.     LITTLE_B2D(&(Data[ 0]), b0[0]);  
  465.     LITTLE_B2D(&(Data[ 4]), b0[1]);  
  466.     LITTLE_B2D(&(Data[ 8]), b0[2]);  
  467.     LITTLE_B2D(&(Data[12]), b0[3]);  
  468.   
  469.     //  
  470.     b0[0] ^= e_key[0];  
  471.     b0[1] ^= e_key[1];  
  472.     b0[2] ^= e_key[2];  
  473.     b0[3] ^= e_key[3];  
  474.   
  475.     kp = e_key + 4;  
  476.   
  477.     switch( k_len ) {  
  478.         case 8 :  
  479.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  480.         case 6 :  
  481.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  482.         case 4 :  
  483.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  484.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  485.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  486.             f_nround(b1, b0, kp); f_nround(b0, b1, kp);  
  487.             f_nround(b1, b0, kp); f_lround(b0, b1, kp);  
  488.     }  
  489.   
  490.     //  
  491.     LITTLE_D2B(b0[0], &(Data[ 0]));  
  492.     LITTLE_D2B(b0[1], &(Data[ 4]));  
  493.     LITTLE_D2B(b0[2], &(Data[ 8]));  
  494.     LITTLE_D2B(b0[3], &(Data[12]));  
  495. }  
  496.   
  497. /*************** Function ************************************************* 
  498. *    
  499. */  
  500. void    AES_Decrypt(  
  501.         void        *CipherKey,     //  鞠/汗龋侩 Round Key  
  502.         BYTE        *Data)          //  涝免仿阑 困茄 喉废阑 啊府虐绰 pointer  
  503. {  
  504.     RIJNDAEL_CIPHER_KEY *RK_Struct=CipherKey;  
  505.     DWORD   *d_key=RK_Struct->RK;    //  64 DWORDs  
  506.     DWORD   k_len=RK_Struct->k_len;  
  507.     u4byte  b0[4], b1[4], *kp;  
  508.   
  509.     LITTLE_B2D(&(Data[ 0]), b0[0]);  
  510.     LITTLE_B2D(&(Data[ 4]), b0[1]);  
  511.     LITTLE_B2D(&(Data[ 8]), b0[2]);  
  512.     LITTLE_B2D(&(Data[12]), b0[3]);  
  513.   
  514.     //  
  515.     b0[0] ^= d_key[0];  
  516.     b0[1] ^= d_key[1];  
  517.     b0[2] ^= d_key[2];  
  518.     b0[3] ^= d_key[3];  
  519.   
  520.     kp = d_key + 4;  
  521.   
  522.     switch( k_len ) {  
  523.         case 8 :  
  524.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  525.         case 6 :  
  526.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  527.         case 4 :  
  528.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  529.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  530.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  531.             i_nround(b1, b0, kp); i_nround(b0, b1, kp);  
  532.             i_nround(b1, b0, kp); i_lround(b0, b1, kp);  
  533.     }  
  534.   
  535.     //  
  536.     LITTLE_D2B(b0[0], &(Data[ 0]));  
  537.     LITTLE_D2B(b0[1], &(Data[ 4]));  
  538.     LITTLE_D2B(b0[2], &(Data[ 8]));  
  539.     LITTLE_D2B(b0[3], &(Data[12]));  
  540. }  
  541.   
  542. /*************** END OF FILE **********************************************/  

 

 

 

下面是我针对上面封装的两个加密解密函数的实现， 很简单的， 密钥是固定的

 

你可以固定一个16个Byte的字符串， 也可以用我代码里面写死的东西， 0x10 到 0x1F

 

[cpp] view plain copy print ?
  1. static int AESEncode (const char* srcString, int srcLen, char** dstString, int* dstLen)  
  2. {  
  3.     //16 * (trunc(string_length / 16) + 1)。  
  4.     char *pOut=0;  
  5.     unsigned int len = 16 * (srcLen/16 + 1);  
  6.   
  7.     BYTE    UserKey[AES_USER_KEY_LEN]={0};  
  8.     BYTE    IV[AES_BLOCK_LEN]={0};  
  9.   
  10.     DWORD   UKLen, IVLen, SrcLen, DstLen;  
  11.     RET_VAL ret;  
  12.     AES_ALG_INFO    AlgInfo;  
  13.     int eelen = 0;  
  14.   
  15.     UKLen = 16;  
  16.     IVLen = 16;  
  17. #ifdef _DEBUG  
  18.     int t = 0x10;  
  19.     for (int i=0; i<16; i++)  
  20.     {  
  21.         UserKey[i] = t+i;  
  22.     }  
  23. #else  
  24.     snprintf ((char*)UserKey, sizeof(UserKey)-1, "%s", g_Config.encryptKey);  
  25. #endif  
  26.   
  27.     pOut = (char*)calloc (1, len+4);  
  28.     if (pOut == NULL)     
  29.         return -1;  
  30.     DstLen = len;  
  31.   
  32.     //  
  33.     AES_SetAlgInfo(AES_ModeType, AES_PadType, IV, &AlgInfo);  
  34.   
  35.     //  Encryption  
  36.     ret = AES_EncKeySchedule(UserKey, UKLen, &AlgInfo);  
  37.     if( ret!=CTR_SUCCESS )    
  38.     {  
  39.         writelog(LOG_DEBUG, "AES_EncKeySchedule() returns.");  
  40.         safe_free (pOut);  
  41.         return -1;  
  42.     }  
  43.     ret = AES_EncInit(&AlgInfo);  
  44.     if( ret!=CTR_SUCCESS )    
  45.     {  
  46.         writelog(LOG_DEBUG, "AES_EncInit() returns.");  
  47.         safe_free (pOut);  
  48.         return -1;  
  49.     }  
  50.   
  51.     ret = AES_EncUpdate(&AlgInfo, (unsigned char*)srcString, SrcLen, (unsigned char*)pOut, &DstLen);  
  52.     if( ret!=CTR_SUCCESS )    
  53.     {  
  54.         writelog(LOG_DEBUG, "AES_EncUpdate() returns.");  
  55.         safe_free (pOut);  
  56.         return -1;  
  57.     }  
  58.   
  59.     eelen = DstLen;  
  60.   
  61.     ret = AES_EncFinal(&AlgInfo, (unsigned char*)pOut+eelen, &DstLen);  
  62.     if( ret!=CTR_SUCCESS )    
  63.     {  
  64.         writelog(LOG_DEBUG, "AES_EncFinal() returns.");  
  65.         safe_free (pOut);  
  66.         return -1;  
  67.     }  
  68.   
  69.     eelen += DstLen;  
  70.     *dstLen = eelen;  
  71.     *dstString = pOut;  
  72.   
  73.     return 0;  
  74.   
  75. }  
  76.   
  77. static int AESDecode (const char* srcString, int srcLen, char** dstString, int* dstLen)  
  78. {  
  79.     //FILE  *pIn, *pOut;  
  80.     char* pOut = 0;  
  81.     unsigned char UserKey[AES_USER_KEY_LEN]={0};  
  82.     unsigned char IV[AES_BLOCK_LEN]={0};  
  83.     //unsigned char SrcData[1024+32], DstData[1024+32];  
  84.     unsigned int  UKLen, IVLen;  
  85.     unsigned int SrcLen, DstLen;  
  86.     RET_VAL ret;  
  87.     AES_ALG_INFO    AlgInfo;  
  88.     int ddlen = 0;  
  89.   
  90.     SrcLen = srcLen;  
  91.       
  92.     pOut = (char*)calloc(1, SrcLen+2);  
  93.     if (pOut == NULL) return -1;  
  94.   
  95.     DstLen = SrcLen;  
  96.   
  97.     UKLen = 16;  
  98.     IVLen = 16;  
  99. #ifdef _DEBUG  
  100.     int t = 0x10;  
  101.     for (int i=0; i<16; i++)  
  102.     {  
  103.         UserKey[i] = t+i;  
  104.     }  
  105. #else  
  106.     snprintf ((char*)UserKey, sizeof(UserKey)-1, "%s", g_Config.encryptKey);  
  107. #endif  
  108.   
  109.     AES_SetAlgInfo(AES_ModeType, AES_PadType, IV, &AlgInfo);  
  110.   
  111.     //Decryption  
  112.     //if( ModeType==AI_ECB || ModeType==AI_CBC )  
  113.     ret = AES_DecKeySchedule(UserKey, UKLen, &AlgInfo);  
  114.     //else if( ModeType==AI_OFB || ModeType==AI_CFB )  
  115.     //  ret = AES_EncKeySchedule(UserKey, UKLen, &AlgInfo);  
  116.   
  117.     if( ret!=CTR_SUCCESS )    
  118.     {  
  119.         writelog(LOG_DEBUG, "AES_DecKeySchedule() returns.");  
  120.         safe_free (pOut);  
  121.         return -1;  
  122.     }  
  123.   
  124.     ret = AES_DecInit(&AlgInfo);  
  125.     if( ret!=CTR_SUCCESS )    
  126.     {  
  127.         writelog(LOG_DEBUG, "AES_DecInit() returns.");  
  128.         safe_free (pOut);  
  129.         return -1;  
  130.     }  
  131.   
  132.     ret = AES_DecUpdate(&AlgInfo, (unsigned char*)srcString, SrcLen, (unsigned char*)pOut, &DstLen);  
  133.     if( ret!=CTR_SUCCESS )    
  134.     {  
  135.         writelog(LOG_DEBUG, "AES_DecUpdate() returns.");  
  136.         safe_free (pOut);  
  137.         return -1;  
  138.     }  
  139.     ddlen = DstLen;  
  140.   
  141.     ret = AES_DecFinal(&AlgInfo, (unsigned char*)pOut+ddlen, &DstLen);  
  142.     if( ret!=CTR_SUCCESS )    
  143.     {  
  144.         writelog(LOG_DEBUG, "AES_DecFinal() returns.");  
  145.         safe_free (pOut);  
  146.         return -1;  
  147.     }  
  148.     ddlen += DstLen;  
  149.     *dstLen = ddlen;  
  150.     *dstString = pOut;  
  151.     return 0;  
  152.   
  153. }  

lhf198484
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
128位AES加密算法C语言实现
11-26
用C语言实现的128位AES加密算法，可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 int Bit64ToChar8 (ElemType bitL64, ElemType ch18) int cnt memset(ch, 0, 8) for(ent-0: cnt<8: cnt++i BitToByte(bit+(cnt<<3), ch+cnt) return 0 /*生成子密钥 int DES Make Subkeys(ElemType key _64, ElemType subkeys [16][48]) ElemType temp 56 int cnt DES PCI Transform(key,temp):/*PCI置换* for(cnt=0;cnt<16;cnt+-){*16轮跌代,产生16个子密钥米 DES ROL(tenp, MOVE TIMES[cnt]);循坏左移* DES PC2 Transform(temp, subkeys cnt]);/PC2置换,产生子密钥体 return o /*密钥置換1*/ int DES PCI Transform(ElemType key [64, ElemType tempts[56])t int cnt for(cnt=0: cnt( 56 cnt++) )empts[cnt]= key[ Ilant] r巳turn /*密钥置換2* int DES PC2 Transform(Elem Type key [56], ElemType tempts[48])i t cnt for(ent =0: cnt< 48: cnt+)I )pbts [cnt]= key [PC 2[cnt]] return /*循环左移*/ int DES ROL (Elem Type data[56], int time)t Elem l'ype temp _56 /*保存将要循环栘动到右边的位* memcpy(temp, data, time) memcpy(temg-time, data+28, time) /*前28位移动 (data-28-time, temp, time) /*后28位移动* memcpy(data 28, data+28+time, 28-time memcpy (data-56-time, temp+time, time) return o /*P置换*/ int DES IP) Iransform(Elemlype data[64)[ ElemType temp _64]: for(cnt templet- datalIP Tablelcnt」」 memcpy(data, temp, 64) return o 第3页 AIS加密算法c语言实现代码 /*IP逆置換* int DES IP 1 Transform(ElemType data[64)( int cnt ElemType temp _64 for(cnt =0: cnt 64: cnt+-)i templet」- dataLIP1 Tablelcrt]」 memcpy(data, temp, 64) return o /*扩展置换*/ int DES E Transform(ElemType data[48])( Int cn ElemType temp48」 for(ent-0: cnt 48: cnt-) temp lent= datale Tablelent memcpy( data, temp, 48 return o P置换 int DES P Transform(ElemType data[32])( t ElemType temp_32] for(ent =0; cnt 32; cnt+-) temp ent-datalP Tablel 11 me.mcpy(data, temp, 32) return 0 /水异或* int DES XOR(Elem Type R[48, Elem Type L[48], int count)I int cnt for(cnt-0: cnt< count: cnt++)i RIant]= lent] return 0 /*S盒置换*/ int DES SBOX (Elem Type data[48]) int cnt int line, row, output int curl, cur for(ent=0; cnt( 8: cnt++i curl cnt:6 cur2= cnt<<2 /*计算在S盒中的行与列来 line=(data cur1<<1)+ data[ cur1+5 row=(data[cur1+1]<<3)+(data[cur1+2]<<2) +(data「cur1-31<<1)+data「cur1+41 output s[cnt][line]trow] /*化为2进制*/ data[cur2]=(output&0X08)>>3 data[cur2+1]=(output&0X04)>>2 data (output&0X02)>1 datalcur 2+3= output&0x01 return o 交换 int DES Swap(ElemType left[32], ElemType right [32]) memcpy(temp, left, 32 memcpy(left, right, 32 memcpy (right, temp, 32 return o 第4页 AIS加密算法c语言实现代码 /*加密单个分组 int DES EncryptBlockElem Type plainBlock[8, ElemType subKeys[l6][48, ElemType cipherBlock[8])I ElemT'ype plainTs [54] ElemType copyRight[48] int cnt Char8ToBit64(plainBlock, plairBits) /米初始置换(IP置换)* DES IP Transform(plainBits /*16轮迭代* for(cnt=0: cnt< 16: cnt+-) memcpy(copyRight, plainBits- 32, 32 /*将右半部分进行扩展置换,从32位扩展到48位*/ DES E Trans form(copyRight) /*将右半部分与子密钥进行异或操作 DES XOR (copy Righ 48) /*异或结果进入S盒,输出32位结果*/ DES SBOX (copyRight) /P置换 DES P Transform(copyRight) /*将明文左半部分与右半部分进行异或* DES XOR (plainBits, copyRight, 32) 最终完成左右部的交换* DES Swap(plainBits, plainBits-32) /逆初始置换(IPI置换)* DES IP 1 Transform (plainBits) Bit64ToChar8(plainBits, cipherBlock) turn o /*解密单个分组 int DES DecryptBlock(ElemType cipherBlock[8, ElemType subKeys[16] 18], ElemType plainBlock [81) ElemType cipherBits[ 641 Elem Type copy Right [48] int cnt Char8ToBit64(cipherBlock, cipherBits) /初始置换(IP置换)* DES IP Transform(cipherBits /*16轮迭代*/ for(cnt-15: cnt >-0: cnt--)i memcpy(copyRight, cipherBits+32, 32 /*将右半部分进行扩展置换,从32位扩展到48位 DES T Trans form(copyright) /*将右半部分与子密钥进行异或操作 DES XOR(copy Right, subKeys [ent], 48) /*异或结果进入S盒,输出32位结果* DES SBOX(copyRight) /米P置换* DES P Transform(copyright) /*将明文h半部分与右半部分进行异或* DES XOR (cipherBits, copy Right, 32) f(cnt /米最终完成左右部的交换* DES Swap(cipherBits, cipherBits+32) /*逆初始置换(IP1置换)* DES IP 1 Transform(cipherBits) Bit64ToChar8(cipherBits, plainBlock) return 0: *加密文件 int DES Encrypt (char xplainFile, char *keyStr, char *cipherFile)t FILE xplain, i*cipher; int count ElcmType plainBlock[81, ciphcrBlock [8, keyBlock 8 第5页 AIS加密算法c语言实现代码 Elem Type bEy 64] ElemType subKeys[16][18] if((plain- fopen(plainFilc, " rb"))--NULL) return Plain FILe OPEN ERROR return CIPHER FILE OPEN ERROR: ))== NULL)( if ((cipher fopen(cipherFile, wb /设置密钥 memcpy (keyBlock, key Str, 8) 将密钥转换为二进制流* Char8ToBit64(keyBlock, bKcy /牛成子密钥* DES Make SubKeys(bEy, subKeys while(!feof plain))( /*每次读8个字节,并返回成功读取的字节数* if((count- fread(plainBlock, sizeof(char),8, plain)) 8){ DES EncryptBlock (plainBlock, subKeys, cipherBlock f(count)[ /*填充*/ memset(plainBlock ount, \0, 7- count) /*最后一个字符休存包括最后一个字符在内的所填充的字符数量水 plainblockl7-8-count DES EncryptBlock (plainBlock, subkeys, cipherBlock fwrite(cipherBlock, sizeof (char), 8, cipher) fclose (plain) f'c. lose(cipher return oK /*解密文件* int DES Decrypt(char *cipherFile, char *key Str, char xplainFile)i FILE* plain,米 cipher int count, times 0 long fileLen Eleml'ype plainBlock [8], cipherBlock[8], keyBlock[8 ElemType bEy _6 ElemType subKeys[16][48] if ((cipher fopen(cipherFile, rb ))= NULL)[ return CIPHEr FILe OPEN ERROR if((plain= fopen(plainFile, wb" ))= NULL) rcturn plain FIle OPEN ERROR /*设置密钥* memcpy(key Block, keyStr, 8) /将密钥转换为二进制流* Char8ToBit64 (keyBlock, bKey) /水生成子密钥* ES Make SubKeys(bKey subKeys) /取文什长度*/ fseek( cipher,0, SEEK END);/将文件指针置尾 fi lelen= ftel l( cipher);/*取文件指针当前位置*/ rewind( CIpher);/*将文件指针重指向文件头* while(1)i 密文的字节数一定是8的整数倍* fread(cipherBlock, sizeof(char), 8, cipher DES DecryptBlock(cipherBlock, subKeys, plainBlock) times +-8 if(times< fileLen fwrite(plainBlock, sizeof(char), 8, plain) /*判断末尾是否被填充米 if(plainBlock 71< 8)i 第6页 AIS加密算法c语言实现代码 for(count=8- plainBlock[7]; count< 7; count++)( if(plainBlock[ count!='\0i break if( count==7){/*有填充* fwrite(plairBlock, sizeof (char), 8- plainBlockL7, plain) else{/*无填充 fwrite(plainBlock, sizeof(char), 8, plain) t'close ( plain) fclose(cipher) return OK int main() clock t a, b a= clockO DES Encrypt( 1. txt, key. txt, 2. txt b=clock o printf("加密消耗%毫秒Ⅶn",b-a); system("pause") a= clock( DES Decrypt( 2. txt, key. txt", 3. txt") printf("解密消耗%毫秒、n",o-a) getcharo return 第7页
AES(ECB、CBC、CFB、CTR)128/192/256加密算法C语言实现
06-12
1、完整的AES(ECB、CBC、CFB、CTR)算法，C语言实现，可用于金融POS安全认证； 2、AES-128、AES-192、AES-256加密/解密 3、内含测试程序，在Linux环境下进入目录后make即可编译，已经在ubuntu16.04环境下编译测试OK；
AES加密算法的原理和代码实现
最新发布
wsrzsfgst的博客
03-05 527
AES（Advanced Encryption Standard）是一种对称加密算法，常用于加密和解密数据。AES算法使用相同的密钥来加密和解密数据，安全性较高，速度较快。
AES加解密算法（C++实现）
03-05
支持 CFB, OFB, CBC, ECB 模式，支持256字节以下任意长度数据加解密，也可以放开成任意长度数据加解密。 其中：AES.cpp 中为算法的实现代码;Test.cpp为测试程序
原生js的RSA和AES加密解密算法
11-26
本文实例为大家分享了js中RSA和AES加密解密详细代码，供大家参考，具体内容如下 <!doctype html> <html> <head> <meta charset='UTF-8'> </head> <body> [removed] function encrypt(data, keyJSON){ var data = new TextEncoder("UTF-8").encode(data); var randomsKeys = geneRandomH
C++实现基于openssl的AES加密，支持文件和字节数组的加密，linux和windows通用
soldier_d的博客
03-31 4406
基于openssl使用C++实现的AES加密功能，支持文件加密，字节数组加密。linux和windows都可使用(PS:使用此方式需要先安装openssl)。 源文件 aes.h #ifndef __AES_H__ #define __AES_H__ #define OS_LINUX 0x00 #define OS_WINDOWS 0x01 #define TYPE_OS OS_WINDOWS //windows下使用 #if TYPE_OS == OS_WINDOWS //去掉编译警告
AES算法描述及C语言实现
热门推荐
彼此当年少，莫负好时光
05-06 7万+
前言 AES算法是当前最流行的对称加密算法，也是一种分组加密算法，分组密码就是把明文分为固定长度的一组一组，每次加密一组数据，直到加密完整个明文数据。AES算法根据分组长度可以分为AES128, AES192，AES256，其所要求的秘钥长度和加密轮数也各不相同。鉴于这三种模式的算法在本质上没有区别，所以本文主要介绍AES-128（数据分组为16字节，秘钥长度为16字节，加密轮数为10轮），并给...
AES算法 C 语言实现(二)
kessity的博客
01-31 3684
  AES(CBC/PKCS5Padding/128)算法C语言实现： aes.h #ifndef __AES_H #define __AES_H #include <string.h> #include <stdint.h> #define LITTLE_ENDIAN_ORDER enum { AES_ENC_TYPE = 1, /* cipher unique type */ AES_ENCRYPTION = 0, AES_DECRYPTION = 1, AES
C语言 AES加解密
Genven_Liang的博客
07-01 9398
AES加解密
分组密码算法AES的C/C++编程实现
m0_63002183的博客
07-10 4052
实验过程中，意识到要实现完整地AES流程是相对十分复杂的，要提前对密钥进行密钥扩展，将明文转化成十六进制变为矩阵，加密过程中，先用初始密钥进行异或，再做九轮字节代换、行移位、列混合；AES加密过程先是明文经过初始化变换，其次再经过九轮循环运算，每一次循环运算都要依次进行字节代换、行移位、列混合和轮密钥加，九轮循环运算结束后，再进行一次最终轮运算，这一轮与前面的九轮的区别除了不进行列混合，其余的不变，也即是最后一轮依次进行字节代换、行移位和轮密钥加，经过这一步骤得到的即为密文。行移位，一个比较简单的置换；
AES加密算法C语言代码实现
09-26
配套文章解析：https://blog.csdn.net/u013469753/article/details/108322140 AES加密算法，AES的全称是Advanced Encryption Standard，意思是高级加密标准。它的出现主要是为了取代DES加密算法的，因为我们都知道DES算法的密钥长度是56Bit，因此算法的理论安全强度是2的56次方。 AES密码与分组密码Rijndael基本上完全一致，Rijndael分组大小和密钥大小都可以为128位、192位和256位。然而AES只要求分组大小为128位，因此只有分组长度为128Bit的Rijndael才称为AES算法。
AES 加密工具（ECB,CBC,CMAC）
06-25
AES工具，支持ECB，CBC加解密运算，以及CMAC运算。支持多种PADDING
用C语言实现的AES加密解密算法
08-26
用C语言实现的AES加密解密算法，用C语言实现的AES加密解密算法
使用 OpenSSL 库实现 AES 加密和解密
billjiang2008的专栏
05-05 2283
该代码中使用了 OpenSSL 中的 AES 函数库，来实现对输入数据的加密和解密。其中，加密和解密都需要输入明文数据和密钥。在本例中，使用了 256 位的密钥进行加密和解密操作。加密后的结果是一个二进制字符串，可以通过 Base64 编码等方式转换为可读的字符串，以便进行网络传输。由于通信加密涉及到较为复杂的加密算法和网络通信，因此需要结合相关的库和框架进行编写。注意，通信加密涉及到的内容还有很多，比如加密算法的选择、密钥管理、随机数生成等。因此在实际应用中需要结合具体的场景和需求进行更为复杂的实现。
【网络安全】网络安全实验5：分析AES算法，并对源码做进一步注释和调试
weixin_45877026的博客
10-21 3351
实验内容：分析AES算法，并对源码做进一步注释和调试 出错位置1：该处出现了字符转化可能会导致数据丢失的错误 解法：经了解，在开头aes.h文件开头处添加”#pragma warning(disable:4244)”语句可强制消除错误。由于实验代码未涉及大数据，强制消除对运行结果无影响。 出错位置2： 解法：强制类型转化为(char *)key 运行结果： 修改后的源码: aes.h #ifndef MY_AES_H #define MY_AES_H #pragma warning(disable
Xcode开发c++程序时，openssl/aes.h: No such file or directory（或者是file not found）怎么解决
limeng93的博客
04-27 4441
解决方法： 1.命令行执行：xcode-select —install,安装xcode命令行工具，等安装完成；这样之后，/usr/local//Cellar/1.0.2k/include/openssl目录里就已经包含了相关的头文件(不同版本的openssl的版本文件夹名可能不同)。 2.在/Applications/Xcode.app/Contents/Developer/Pla
linux aes 源码,代码阅读 - Linux\kernel\linux-5.0\drivers\crypto\omap-aes.h
weixin_30464195的博客
05-12 163
/** Cryptographic API.** Support for OMAP AES HW ACCELERATOR defines** Copyright (c) 2015 Texas Instruments Incorporated** This program is free software; you can redistribute it and/or modify* it unde...
opensuse下遭遇openssl/aes.h: No such file or directory解决办法
xinwenfei的专栏
03-02 8544
opensuse下遭遇openssl/aes.h: No such file or directory解决办法 使用Linux安装程序总会遇到点麻烦，因为使用Ubuntu的人太多，所以遇到问题，基于Ubuntu的问题总是可以很容易解决，但是如果你使用opensuse可能相当一部分问题你无法直接得到答案，而只能慢慢探索，看到网上一大堆 apt-get install或者yum in
基于内核模式下AES加密解密算法的C代码实现
06-06
以下是基于内核模式下AES加密解密算法的C代码实现： ```c #include <linux/crypto.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #define MSG_LEN 16 static char *key = "01234567890123456789012345678901"; // 32字节的密钥 static char *msg = "Hello, world!"; // 16字节的明文数据 static char encrypted[MSG_LEN]; static char decrypted[MSG_LEN]; static int __init aes_init(void) { struct crypto_cipher *tfm; int i; printk(KERN_INFO "AES module loaded.\n"); tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC); if (IS_ERR(tfm)) { printk(KERN_ERR "Unable to allocate cipher.\n"); return -1; } crypto_cipher_setkey(tfm, key, strlen(key)); crypto_cipher_encrypt_one(tfm, encrypted, msg); printk(KERN_INFO "Encrypted message: "); for (i = 0; i < MSG_LEN; i++) { printk("%02x ", encrypted[i]); } printk("\n"); crypto_cipher_decrypt_one(tfm, decrypted, encrypted); printk(KERN_INFO "Decrypted message: "); for (i = 0; i < MSG_LEN; i++) { printk("%c", decrypted[i]); } printk("\n"); crypto_free_cipher(tfm); return 0; } static void __exit aes_exit(void) { printk(KERN_INFO "AES module unloaded.\n"); } module_init(aes_init); module_exit(aes_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("AES encryption/decryption module"); MODULE_AUTHOR("Your Name"); ``` 在此示例代码中，我们使用了Linux内核中的`crypto`库来进行AES加密解密。首先，我们定义了一个32字节的密钥和一个16字节的明文数据。然后，我们分配了一个AES加密解密算法的上下文，设置了密钥并对明文进行加密。接着，我们打印出加密后的数据，并对其进行解密并打印出解密后的结果。最后，我们释放了上下文并完成了模块的加载。 需要注意的是，在内核中进行加密解密操作需要特殊的权限，因此需要使用root权限来加载和卸载此模块。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值