lhf198484
lhf198484

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



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   
  6. #include   
  7. #include   
  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  
#ifndef _AES_H #define _AES_H /*************** Header files *********************************************/ #include #include #include //#include "cryptcom.h" #define AES_ModeType AI_ECB #define AES_PadType AI_PKCS_PADDING /*************** Assertions ***********************************************/ //////// Define the Endianness //////// #undef BIG_ENDIAN #undef LITTLE_ENDIAN #define USER_LITTLE_ENDIAN #if defined(USER_BIG_ENDIAN) #define BIG_ENDIAN #elif defined(USER_LITTLE_ENDIAN) #define LITTLE_ENDIAN #else #if 0 #define BIG_ENDIAN // Big-Endian machine with pointer casting #elif defined(_MSC_VER) #define LITTLE_ENDIAN // Little-Endian machine with pointer casting #else #error #endif #endif /*************** Macros ***************************************************/ //////// rotate by using shift operations //////// #if defined(_MSC_VER) #define ROTL_DWORD(x, n) _lrotl((x), (n)) #define ROTR_DWORD(x, n) _lrotr((x), (n)) #else #define ROTL_DWORD(x, n) ( (DWORD)((x) << (n)) | (DWORD)((x) >> (32-(n))) ) #define ROTR_DWORD(x, n) ( (DWORD)((x) >> (n)) | (DWORD)((x) << (32-(n))) ) #endif //////// reverse the byte order of DWORD(DWORD:4-bytes integer) and WORD. #define ENDIAN_REVERSE_DWORD(dwS) ( (ROTL_DWORD((dwS), 8) & 0x00ff00ff) | (ROTL_DWORD((dwS), 24) & 0xff00ff00) ) //////// move DWORD type to BYTE type and BYTE type to DWORD type #if defined(BIG_ENDIAN) //// Big-Endian machine #define BIG_B2D(B, D) D = *(DWORD *)(B) #define BIG_D2B(D, B) *(DWORD *)(B) = (DWORD)(D) #define LITTLE_B2D(B, D) D = ENDIAN_REVERSE_DWORD(*(DWORD *)(B)) #define LITTLE_D2B(D, B) *(DWORD *)(B) = ENDIAN_REVERSE_DWORD(D) #elif defined(LITTLE_ENDIAN) //// Little-Endian machine #define BIG_B2D(B, D) D = ENDIAN_REVERSE_DWORD(*(DWORD *)(B)) #define BIG_D2B(D, B) *(DWORD *)(B) = ENDIAN_REVERSE_DWORD(D) #define LITTLE_B2D(B, D) D = *(DWORD *)(B) #define LITTLE_D2B(D, B) *(DWORD *)(B) = (DWORD)(D) #else #error ERROR : Invalid DataChangeType #endif /*************** Definitions / Macros *************************************/ //// 泅犁 酒贰狼 4俺 规侥阑 瘤盔茄促. #define AI_ECB 1 #define AI_CBC 2 #define AI_OFB 3 #define AI_CFB 4 //// 泅犁 酒贰狼 滴 padding阑 瘤盔茄促. #define AI_NO_PADDING 1 // Padding 绝澜(涝仿捞 16官捞飘狼 硅荐) #define AI_PKCS_PADDING 2 // padding登绰 官捞飘 荐肺 padding //// AES俊 包访等 惑荐甸 #define AES_BLOCK_LEN 16 // in BYTEs #define AES_USER_KEY_LEN 32 // (16,24,32) in BYTEs #define AES_NO_ROUNDS 10 #define AES_NO_ROUNDKEY 68 // in DWORDs /*************** New Data Types *******************************************/ //////// Determine data types depand on the processor and compiler. #define BOOL int // 1-bit data type #define BYTE unsigned char // unsigned 1-byte data type #define WORD unsigned short int // unsigned 2-bytes data type #define DWORD unsigned int // unsigned 4-bytes data type #define RET_VAL DWORD // return values //// AES.. typedef struct{ DWORD ModeID; // ECB or CBC DWORD PadType; // 喉废鞠龋狼 Padding type BYTE IV[AES_BLOCK_LEN]; // Initial Vector BYTE ChainVar[AES_BLOCK_LEN]; // Chaining Variable BYTE Buffer[AES_BLOCK_LEN]; // Buffer for unfilled block DWORD BufLen; // Buffer狼 蜡瓤 官捞飘 荐 DWORD RoundKey[AES_NO_ROUNDKEY]; // 扼款靛 虐狼 DWORD 荐 } AES_ALG_INFO; /*************** Constant (Error Code) ************************************/ //// Error Code - 沥府窍绊, 利寸洒 免仿秦具 窃. #define CTR_SUCCESS 0 #define CTR_FATAL_ERROR 0x1001 #define CTR_INVALID_USERKEYLEN 0x1002 // 厚剐虐狼 辨捞啊 何利例窃. #define CTR_PAD_CHECK_ERROR 0x1003 // #define CTR_DATA_LEN_ERROR 0x1004 // 乞巩狼 辨捞啊 何利例窃. #define CTR_CIPHER_LEN_ERROR 0x1005 // 鞠龋巩捞 喉废狼 硅荐啊 酒丛. #ifdef __cplusplus extern "C" { #endif /*************** Prototypes ***********************************************/ //// 单捞鸥 鸥涝 AES_ALG_INFO俊 mode, padding 辆幅 棺 IV 蔼阑 檬扁拳茄促. void AES_SetAlgInfo( DWORD ModeID, DWORD PadType, BYTE *IV, AES_ALG_INFO *AlgInfo); //// 涝仿等 AES_USER_KEY_LEN官牢飘狼 厚剐虐肺 扼款靛 虐 积己 RET_VAL AES_EncKeySchedule( BYTE *UserKey, // 荤侩磊 厚剐虐甫 涝仿窃. DWORD UserKeyLen, AES_ALG_INFO *AlgInfo); // 鞠汗龋侩 Round Key啊 历厘凳. RET_VAL AES_DecKeySchedule( BYTE *UserKey, // 荤侩磊 厚剐虐甫 涝仿窃. DWORD UserKeyLen, AES_ALG_INFO *AlgInfo); // 鞠汗龋侩 Round Key啊 历厘凳. //// Init/Update/Final 屈侥阑 鞠龋拳. RET_VAL AES_EncInit( AES_ALG_INFO *AlgInfo); RET_VAL AES_EncUpdate( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 乞巩捞 涝仿凳. DWORD PlainTxtLen, BYTE *CipherTxt, // 鞠龋巩捞 免仿凳. DWORD *CipherTxtLen); RET_VAL AES_EncFinal( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿凳. DWORD *CipherTxtLen); //// Init/Update/Final 屈侥阑 汗龋拳. RET_VAL AES_DecInit( AES_ALG_INFO *AlgInfo); RET_VAL AES_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 涝仿凳. DWORD CipherTxtLen, BYTE *PlainTxt, // 汗龋巩捞 免仿凳. DWORD *PlainTxtLen); RET_VAL AES_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 汗龋巩捞 免仿凳. DWORD *PlainTxtLen); /*************** END OF FILE **********************************************/ #ifdef __cplusplus } #endif #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
  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
  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
  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
  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
  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
  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 **********************************************/  
/*************** Header files *********************************************/ #include "aes.h" /*************** Assertions ***********************************************/ /*************** Definitions / Macros ************************************/ #define BlockCopy(pbDst, pbSrc) { / ((DWORD *)(pbDst))[0] = ((DWORD *)(pbSrc))[0]; / ((DWORD *)(pbDst))[1] = ((DWORD *)(pbSrc))[1]; / ((DWORD *)(pbDst))[2] = ((DWORD *)(pbSrc))[2]; / ((DWORD *)(pbDst))[3] = ((DWORD *)(pbSrc))[3]; / } #define BlockXor(pbDst, phSrc1, phSrc2) { / ((DWORD *)(pbDst))[0] = ((DWORD *)(phSrc1))[0] / ^ ((DWORD *)(phSrc2))[0]; / ((DWORD *)(pbDst))[1] = ((DWORD *)(phSrc1))[1] / ^ ((DWORD *)(phSrc2))[1]; / ((DWORD *)(pbDst))[2] = ((DWORD *)(phSrc1))[2] / ^ ((DWORD *)(phSrc2))[2]; / ((DWORD *)(pbDst))[3] = ((DWORD *)(phSrc1))[3] / ^ ((DWORD *)(phSrc2))[3]; / } /*************** New Data Types *******************************************/ /*************** Global Variables *****************************************/ /*************** Prototypes ***********************************************/ void AES_Encrypt( void *CipherKey, // 鞠/汗龋侩 Round Key BYTE *Data); // 涝免仿阑 困茄 喉废阑 啊府虐绰 pointer void AES_Decrypt( void *CipherKey, // 鞠/汗龋侩 Round Key BYTE *Data); // 涝免仿阑 困茄 喉废阑 啊府虐绰 pointer /*************** Constants ************************************************/ /*************** Constants ************************************************/ /*************** Macros ***************************************************/ /*************** Global Variables *****************************************/ /*************** Function ************************************************* * */ void AES_SetAlgInfo( DWORD ModeID, DWORD PadType, BYTE *IV, AES_ALG_INFO *AlgInfo) { AlgInfo->ModeID = ModeID; AlgInfo->PadType = PadType; if( IV!=NULL ) memcpy(AlgInfo->IV, IV, AES_BLOCK_LEN); else memset(AlgInfo->IV, 0, AES_BLOCK_LEN); } /*************** Function ************************************************* * */ static RET_VAL PaddSet( BYTE *pbOutBuffer, DWORD dRmdLen, DWORD dBlockLen, DWORD dPaddingType) { DWORD dPadLen; switch( dPaddingType ) { case AI_NO_PADDING : if( dRmdLen==0 ) return 0; else return CTR_DATA_LEN_ERROR; case AI_PKCS_PADDING : dPadLen = dBlockLen - dRmdLen; memset(pbOutBuffer+dRmdLen, (char)dPadLen, (int)dPadLen); return dPadLen; default : return CTR_FATAL_ERROR; } } /*************** Function ************************************************* * */ static RET_VAL PaddCheck( BYTE *pbOutBuffer, DWORD dBlockLen, DWORD dPaddingType) { DWORD i, dPadLen; switch( dPaddingType ) { case AI_NO_PADDING : return 0; // padding等 单捞鸥啊 0官捞飘烙. case AI_PKCS_PADDING : dPadLen = pbOutBuffer[dBlockLen-1]; if( ((int)dPadLen<=0) || (dPadLen>(int)dBlockLen) ) return CTR_PAD_CHECK_ERROR; for( i=1; i<=dPadLen; i++) if( pbOutBuffer[dBlockLen-i] != dPadLen ) return CTR_PAD_CHECK_ERROR; return dPadLen; default : return CTR_FATAL_ERROR; } } /************************************************************************** * */ RET_VAL AES_EncInit( AES_ALG_INFO *AlgInfo) { AlgInfo->BufLen = 0; if( AlgInfo->ModeID!=AI_ECB ) memcpy(AlgInfo->ChainVar, AlgInfo->IV, AES_BLOCK_LEN); return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL ECB_EncUpdate( AES_ALG_INFO *AlgInfo, // BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD PlainTxtLen, // 涝仿登绰 乞巩狼 官捞飘 荐 BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; // *CipherTxtLen = BufLen + PlainTxtLen; // No one block if( *CipherTxtLenBuffer+BufLen, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen += PlainTxtLen; *CipherTxtLen = 0; return CTR_SUCCESS; } // control the case that PlainTxt and CipherTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen)); PlainTxt += BlockLen - BufLen; PlainTxtLen -= BlockLen - BufLen; // core part BlockCopy(CipherTxt, AlgInfo->Buffer); AES_Encrypt(ScheduledKey, CipherTxt); CipherTxt += BlockLen; while( PlainTxtLen>=BlockLen ) { BlockCopy(CipherTxt, PlainTxt); AES_Encrypt(ScheduledKey, CipherTxt); PlainTxt += BlockLen; CipherTxt += BlockLen; PlainTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen = PlainTxtLen; *CipherTxtLen -= PlainTxtLen; // control the case that PlainTxt and CipherTxt are the same buffer return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CBC_EncUpdate( AES_ALG_INFO *AlgInfo, // BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD PlainTxtLen, // 涝仿登绰 乞巩狼 官捞飘 荐 BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; // *CipherTxtLen = BufLen + PlainTxtLen; // No one block if( *CipherTxtLenBuffer+BufLen, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen += PlainTxtLen; *CipherTxtLen = 0; return CTR_SUCCESS; } // control the case that PlainTxt and CipherTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen)); PlainTxt += BlockLen - BufLen; PlainTxtLen -= BlockLen - BufLen; // core part BlockXor(CipherTxt, AlgInfo->ChainVar, AlgInfo->Buffer); AES_Encrypt(ScheduledKey, CipherTxt); CipherTxt += BlockLen; while( PlainTxtLen>=BlockLen ) { BlockXor(CipherTxt, CipherTxt-BlockLen, PlainTxt); AES_Encrypt(ScheduledKey, CipherTxt); PlainTxt += BlockLen; CipherTxt += BlockLen; PlainTxtLen -= BlockLen; } BlockCopy(AlgInfo->ChainVar, CipherTxt-BlockLen); // save remained data memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen = PlainTxtLen; *CipherTxtLen -= PlainTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL OFB_EncUpdate( AES_ALG_INFO *AlgInfo, // BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD PlainTxtLen, // 涝仿登绰 乞巩狼 官捞飘 荐 BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *CipherTxtLen = BufLen + PlainTxtLen; // No one block if( *CipherTxtLenBuffer+BufLen, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen += PlainTxtLen; *CipherTxtLen = 0; return CTR_SUCCESS; } // control the case that PlainTxt and CipherTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen)); PlainTxt += BlockLen - BufLen; PlainTxtLen -= BlockLen - BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(CipherTxt, AlgInfo->ChainVar, AlgInfo->Buffer); CipherTxt += BlockLen; while( PlainTxtLen>=BlockLen ) { AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(CipherTxt, AlgInfo->ChainVar, PlainTxt); PlainTxt += BlockLen; CipherTxt += BlockLen; PlainTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + PlainTxtLen; *CipherTxtLen -= PlainTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CFB_EncUpdate( AES_ALG_INFO *AlgInfo, // BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD PlainTxtLen, // 涝仿登绰 乞巩狼 官捞飘 荐 BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *CipherTxtLen = BufLen + PlainTxtLen; // No one block if( *CipherTxtLenBuffer+BufLen, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen += PlainTxtLen; *CipherTxtLen = 0; return CTR_SUCCESS; } // control the case that PlainTxt and CipherTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block memcpy(AlgInfo->Buffer+BufLen, PlainTxt, (int)(BlockLen - BufLen)); PlainTxt += BlockLen - BufLen; PlainTxtLen -= BlockLen - BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer); BlockCopy(CipherTxt, AlgInfo->ChainVar); CipherTxt += BlockLen; while( PlainTxtLen>=BlockLen ) { AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, PlainTxt); BlockCopy(CipherTxt, AlgInfo->ChainVar); PlainTxt += BlockLen; CipherTxt += BlockLen; PlainTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, PlainTxt, (int)PlainTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + PlainTxtLen; *CipherTxtLen -= PlainTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL AES_EncUpdate( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD PlainTxtLen, // 涝仿登绰 乞巩狼 官捞飘 荐 BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { switch( AlgInfo->ModeID ) { case AI_ECB : return ECB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen); case AI_CBC : return CBC_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen); case AI_OFB : return OFB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen); case AI_CFB : return CFB_EncUpdate(AlgInfo, PlainTxt, PlainTxtLen, CipherTxt, CipherTxtLen); default : return CTR_FATAL_ERROR; } } /************************************************************************** * */ static RET_VAL ECB_EncFinal( AES_ALG_INFO *AlgInfo, // BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; DWORD PaddByte; // Padding PaddByte = PaddSet(AlgInfo->Buffer, BufLen, BlockLen, AlgInfo->PadType); if( PaddByte>BlockLen ) return PaddByte; if( PaddByte==0 ) { *CipherTxtLen = 0; return CTR_SUCCESS; } // core part BlockCopy(CipherTxt, AlgInfo->Buffer); AES_Encrypt(ScheduledKey, CipherTxt); // *CipherTxtLen = BlockLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CBC_EncFinal( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; DWORD PaddByte; // Padding PaddByte = PaddSet(AlgInfo->Buffer, BufLen, BlockLen, AlgInfo->PadType); if( PaddByte>BlockLen ) return PaddByte; if( PaddByte==0 ) { *CipherTxtLen = 0; return CTR_SUCCESS; } // core part BlockXor(CipherTxt, AlgInfo->Buffer, AlgInfo->ChainVar); AES_Encrypt(ScheduledKey, CipherTxt); BlockCopy(AlgInfo->ChainVar, CipherTxt); // *CipherTxtLen = BlockLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL OFB_EncFinal( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; DWORD i; // Check Output Memory Size *CipherTxtLen = BlockLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); for( i=0; iBuffer[i] ^ AlgInfo->ChainVar[i]); // *CipherTxtLen = BufLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CFB_EncFinal( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *CipherTxtLen = BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer); memcpy(CipherTxt, AlgInfo->ChainVar, BufLen); // *CipherTxtLen = BufLen; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL AES_EncFinal( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD *CipherTxtLen) // 免仿登绰 鞠龋巩狼 官捞飘 荐 { switch( AlgInfo->ModeID ) { case AI_ECB : return ECB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen); case AI_CBC : return CBC_EncFinal(AlgInfo, CipherTxt, CipherTxtLen); case AI_OFB : return OFB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen); case AI_CFB : return CFB_EncFinal(AlgInfo, CipherTxt, CipherTxtLen); default : return CTR_FATAL_ERROR; } } /************************************************************************** * */ RET_VAL AES_DecInit(AES_ALG_INFO *AlgInfo) { AlgInfo->BufLen = 0; if( AlgInfo->ModeID!=AI_ECB ) memcpy(AlgInfo->ChainVar, AlgInfo->IV, AES_BLOCK_LEN); return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL ECB_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 涝仿登绰 鞠龋巩狼 pointer DWORD CipherTxtLen, // 涝仿登绰 鞠龋巩狼 官捞飘 荐 BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; // *PlainTxtLen = BufLen + CipherTxtLen; // No one block if( BufLen+CipherTxtLen <= BlockLen ) { memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen += CipherTxtLen; *PlainTxtLen = 0; return CTR_SUCCESS; } // control the case that CipherTxt and PlainTxt are the same buffer if( CipherTxt==PlainTxt ) return CTR_FATAL_ERROR; // first block *PlainTxtLen = BufLen + CipherTxtLen; memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen)); CipherTxt += BlockLen - BufLen; CipherTxtLen -= BlockLen - BufLen; // core part BlockCopy(PlainTxt, AlgInfo->Buffer); AES_Decrypt(ScheduledKey, PlainTxt); PlainTxt += BlockLen; while( CipherTxtLen>BlockLen ) { BlockCopy(PlainTxt, CipherTxt); AES_Decrypt(ScheduledKey, PlainTxt); CipherTxt += BlockLen; PlainTxt += BlockLen; CipherTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen; *PlainTxtLen -= CipherTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CBC_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 涝仿登绰 鞠龋巩狼 pointer DWORD CipherTxtLen, // 涝仿登绰 鞠龋巩狼 官捞飘 荐 BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; // Check Output Memory Size *PlainTxtLen = BufLen + CipherTxtLen; // No one block if( BufLen+CipherTxtLen <= BlockLen ) { memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen += CipherTxtLen; *PlainTxtLen = 0; return CTR_SUCCESS; } // control the case that CipherTxt and PlainTxt are the same buffer if( CipherTxt==PlainTxt ) return CTR_FATAL_ERROR; // first block *PlainTxtLen = BufLen + CipherTxtLen; memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen)); CipherTxt += BlockLen - BufLen; CipherTxtLen -= BlockLen - BufLen; // core part BlockCopy(PlainTxt, AlgInfo->Buffer); AES_Decrypt(ScheduledKey, PlainTxt); BlockXor(PlainTxt, PlainTxt, AlgInfo->ChainVar); PlainTxt += BlockLen; if( CipherTxtLen<=BlockLen ) { BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer); } else { if( CipherTxtLen>BlockLen ) { BlockCopy(PlainTxt, CipherTxt); AES_Decrypt(ScheduledKey, PlainTxt); BlockXor(PlainTxt, PlainTxt, AlgInfo->Buffer); CipherTxt += BlockLen; PlainTxt += BlockLen; CipherTxtLen -= BlockLen; } while( CipherTxtLen>BlockLen ) { BlockCopy(PlainTxt, CipherTxt); AES_Decrypt(ScheduledKey, PlainTxt); BlockXor(PlainTxt, PlainTxt, CipherTxt-BlockLen); CipherTxt += BlockLen; PlainTxt += BlockLen; CipherTxtLen -= BlockLen; } BlockCopy(AlgInfo->ChainVar, CipherTxt-BlockLen); } // save remained data memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen; *PlainTxtLen -= CipherTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL OFB_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 涝仿登绰 鞠龋巩狼 pointer DWORD CipherTxtLen, // 涝仿登绰 鞠龋巩狼 官捞飘 荐 BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *PlainTxtLen = BufLen + CipherTxtLen; // No one block if( BufLen+CipherTxtLen <= BlockLen ) { memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen += CipherTxtLen; *PlainTxtLen = 0; return CTR_SUCCESS; } // control the case that CipherTxt and PlainTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block *PlainTxtLen = BufLen + CipherTxtLen; memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen)); CipherTxt += BlockLen - BufLen; CipherTxtLen -= BlockLen - BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(PlainTxt, AlgInfo->ChainVar, AlgInfo->Buffer); PlainTxt += BlockLen; while( CipherTxtLen>BlockLen ) { AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(PlainTxt, AlgInfo->ChainVar, CipherTxt); CipherTxt += BlockLen; PlainTxt += BlockLen; CipherTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen; *PlainTxtLen -= CipherTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ static RET_VAL CFB_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 涝仿登绰 鞠龋巩狼 pointer DWORD CipherTxtLen, // 涝仿登绰 鞠龋巩狼 官捞飘 荐 BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *PlainTxtLen = BufLen + CipherTxtLen; // No one block if( BufLen+CipherTxtLen <= BlockLen ) { memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen += CipherTxtLen; *PlainTxtLen = 0; return CTR_SUCCESS; } // control the case that CipherTxt and PlainTxt are the same buffer if( PlainTxt==CipherTxt ) return CTR_FATAL_ERROR; // first block *PlainTxtLen = BufLen + CipherTxtLen; memcpy(AlgInfo->Buffer+BufLen, CipherTxt, (int)(BlockLen - BufLen)); CipherTxt += BlockLen - BufLen; CipherTxtLen -= BlockLen - BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(PlainTxt, AlgInfo->ChainVar, AlgInfo->Buffer); BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer); PlainTxt += BlockLen; while( CipherTxtLen>BlockLen ) { AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(PlainTxt, AlgInfo->ChainVar, CipherTxt); BlockCopy(AlgInfo->ChainVar, CipherTxt); CipherTxt += BlockLen; PlainTxt += BlockLen; CipherTxtLen -= BlockLen; } // save remained data memcpy(AlgInfo->Buffer, CipherTxt, (int)CipherTxtLen); AlgInfo->BufLen = (AlgInfo->BufLen&0xF0000000) + CipherTxtLen; *PlainTxtLen -= CipherTxtLen; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL AES_DecUpdate( AES_ALG_INFO *AlgInfo, BYTE *CipherTxt, // 鞠龋巩捞 免仿瞪 pointer DWORD CipherTxtLen, // 免仿登绰 鞠龋巩狼 官捞飘 荐 BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD *PlainTxtLen) // 涝仿登绰 乞巩狼 官捞飘 荐 { switch( AlgInfo->ModeID ) { case AI_ECB : return ECB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen); case AI_CBC : return CBC_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen); case AI_OFB : return OFB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen); case AI_CFB : return CFB_DecUpdate(AlgInfo, CipherTxt, CipherTxtLen, PlainTxt, PlainTxtLen); default : return CTR_FATAL_ERROR; } } /************************************************************************** * */ RET_VAL ECB_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; RET_VAL ret; // Check Output Memory Size if( BufLen==0 ) { *PlainTxtLen = 0; return CTR_SUCCESS; } *PlainTxtLen = BlockLen; if( BufLen!=BlockLen ) return CTR_CIPHER_LEN_ERROR; // core part BlockCopy(PlainTxt, AlgInfo->Buffer); AES_Decrypt(ScheduledKey, PlainTxt); // Padding Check ret = PaddCheck(PlainTxt, BlockLen, AlgInfo->PadType); if( ret==(DWORD)-3 ) return CTR_PAD_CHECK_ERROR; if( ret==(DWORD)-1 ) return CTR_FATAL_ERROR; *PlainTxtLen = BlockLen - ret; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL CBC_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BlockLen=AES_BLOCK_LEN, BufLen=AlgInfo->BufLen; RET_VAL ret; // Check Output Memory Size if( BufLen==0 ) { *PlainTxtLen = 0; return CTR_SUCCESS; } *PlainTxtLen = BlockLen; if( BufLen!=BlockLen ) return CTR_CIPHER_LEN_ERROR; // core part BlockCopy(PlainTxt, AlgInfo->Buffer); AES_Decrypt(ScheduledKey, PlainTxt); BlockXor(PlainTxt, PlainTxt, AlgInfo->ChainVar); BlockCopy(AlgInfo->ChainVar, AlgInfo->Buffer); // Padding Check ret = PaddCheck(PlainTxt, BlockLen, AlgInfo->PadType); if( ret==(DWORD)-3 ) return CTR_PAD_CHECK_ERROR; if( ret==(DWORD)-1 ) return CTR_FATAL_ERROR; *PlainTxtLen = BlockLen - ret; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL OFB_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD i, BufLen=AlgInfo->BufLen; // Check Output Memory Size *PlainTxtLen = BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); for( i=0; iBuffer[i] ^ AlgInfo->ChainVar[i]); *PlainTxtLen = BufLen; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL CFB_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 乞巩捞 免仿瞪 pointer DWORD *PlainTxtLen) // 免仿登绰 乞巩狼 官捞飘 荐 { DWORD *ScheduledKey=AlgInfo->RoundKey; DWORD BufLen=AlgInfo->BufLen; // Check Output Memory Size *PlainTxtLen = BufLen; // core part AES_Encrypt(ScheduledKey, AlgInfo->ChainVar); BlockXor(AlgInfo->ChainVar, AlgInfo->ChainVar, AlgInfo->Buffer); memcpy(PlainTxt, AlgInfo->ChainVar, BufLen); *PlainTxtLen = BufLen; // return CTR_SUCCESS; } /************************************************************************** * */ RET_VAL AES_DecFinal( AES_ALG_INFO *AlgInfo, BYTE *PlainTxt, // 涝仿登绰 乞巩狼 pointer DWORD *PlainTxtLen) // 涝仿登绰 乞巩狼 官捞飘 荐 { switch( AlgInfo->ModeID ) { case AI_ECB : return ECB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen); case AI_CBC : return CBC_DecFinal(AlgInfo, PlainTxt, PlainTxtLen); case AI_OFB : return OFB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen); case AI_CFB : return CFB_DecFinal(AlgInfo, PlainTxt, PlainTxtLen); default : return CTR_FATAL_ERROR; } } /*************** 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 **********************************************/  
/*************** Header files *********************************************/ #include "aes.h" /*************** Assertions ***********************************************/ /*************** New Data Types *******************************************/ typedef struct { DWORD k_len; DWORD RK[64]; } RIJNDAEL_CIPHER_KEY; /*************** Definitions / Macros ************************************/ #define u1byte BYTE #define u4byte DWORD #define rotl ROTL_DWORD #define rotr ROTR_DWORD #define byte(x,n) ((u1byte)((x) >> (8 * n))) #define LARGE_TABLES #define ff_mult(a,b) (a && b ? pow_tab[(log_tab[a] + log_tab[b]) % 255] : 0) #ifdef LARGE_TABLES #define ls_box(x) / ( fl_tab[0][byte(x, 0)] ^ / fl_tab[1][byte(x, 1)] ^ / fl_tab[2][byte(x, 2)] ^ / fl_tab[3][byte(x, 3)] ) #else #define ls_box(x) / ((u4byte)sbx_tab[byte(x, 0)] << 0) ^ / ((u4byte)sbx_tab[byte(x, 1)] << 8) ^ / ((u4byte)sbx_tab[byte(x, 2)] << 16) ^ / ((u4byte)sbx_tab[byte(x, 3)] << 24) #endif /*************** Global Variables *****************************************/ static u1byte log_tab[256]; static u1byte pow_tab[256]; static u1byte sbx_tab[256]; static u1byte isb_tab[256]; static u4byte rco_tab[ 10]; static u4byte ft_tab[4][256]; static u4byte it_tab[4][256]; #ifdef LARGE_TABLES static u4byte fl_tab[4][256]; static u4byte il_tab[4][256]; #endif static u4byte tab_gen = 0; /*************** Prototypes ***********************************************/ static void gen_tabs(void) { u4byte i, t; u1byte p, q; /* log and power tables for GF(2**8) finite field with */ /* 0x11b as modular polynomial - the simplest prmitive */ /* root is 0x11, used here to generate the tables */ log_tab[7] = 0; for(i = 0,p = 1; i < 256; ++i) { pow_tab[i] = (BYTE)p; log_tab[p] = (BYTE)i; p = (BYTE)(p ^ (p << 1) ^ (p & 0x80 ? 0x01b : 0)); } log_tab[1] = 0; p = 1; for(i = 0; i < 10; ++i) { rco_tab[i] = p; p = (BYTE)((p << 1) ^ (p & 0x80 ? 0x1b : 0)); } /* note that the affine byte transformation matrix in */ /* rijndael specification is in big endian format with */ /* bit 0 as the most significant bit. In the remainder */ /* of the specification the bits are numbered from the */ /* least significant end of a byte. */ for(i = 0; i < 256; ++i) { p = (BYTE)(i ? pow_tab[255 - log_tab[i]] : 0); q = p; q = (BYTE)((q >> 7) | (q << 1)); p ^= q; q = (BYTE)((q >> 7) | (q << 1)); p ^= q; q = (BYTE)((q >> 7) | (q << 1)); p ^= q; q = (BYTE)((q >> 7) | (q << 1)); p ^= q ^ 0x63; sbx_tab[i] = (u1byte)p; isb_tab[p] = (u1byte)i; } for(i = 0; i < 256; ++i) { p = sbx_tab[i]; #ifdef LARGE_TABLES t = p; fl_tab[0][i] = t; fl_tab[1][i] = rotl(t, 8); fl_tab[2][i] = rotl(t, 16); fl_tab[3][i] = rotl(t, 24); #endif t = ((u4byte)ff_mult(2, p)) | ((u4byte)p << 8) | ((u4byte)p << 16) | ((u4byte)ff_mult(3, p) << 24); ft_tab[0][i] = t; ft_tab[1][i] = rotl(t, 8); ft_tab[2][i] = rotl(t, 16); ft_tab[3][i] = rotl(t, 24); p = isb_tab[i]; #ifdef LARGE_TABLES t = p; il_tab[0][i] = t; il_tab[1][i] = rotl(t, 8); il_tab[2][i] = rotl(t, 16); il_tab[3][i] = rotl(t, 24); #endif t = ((u4byte)ff_mult(14, p)) | ((u4byte)ff_mult( 9, p) << 8) | ((u4byte)ff_mult(13, p) << 16) | ((u4byte)ff_mult(11, p) << 24); it_tab[0][i] = t; it_tab[1][i] = rotl(t, 8); it_tab[2][i] = rotl(t, 16); it_tab[3][i] = rotl(t, 24); } tab_gen = 1; }; #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b) #define imix_col(y,x) / u = star_x(x); / v = star_x(u); / w = star_x(v); / t = w ^ (x); / (y) = u ^ v ^ w; / (y) ^= rotr(u ^ t, 8) ^ / rotr(v ^ t, 16) ^ / rotr(t,24) /************************************************************************** * * Function Description ... * * Return values: * - CTR_SUCCESS 窃荐啊 己傍利栏肺 荐青凳. * ... */ static void RIJNDAEL_KeySchedule( BYTE *UserKey, // 荤侩磊 厚剐虐 涝仿 DWORD k_len, // 荤侩磊 厚剐虐狼 DWORD 荐 DWORD *e_key) // 鞠龋侩 Round Key 积己/免仿 { u4byte i, t; //// if(!tab_gen) gen_tabs(); LITTLE_B2D(&(UserKey[ 0]), e_key[0]); LITTLE_B2D(&(UserKey[ 4]), e_key[1]); LITTLE_B2D(&(UserKey[ 8]), e_key[2]); LITTLE_B2D(&(UserKey[12]), e_key[3]); switch(k_len) { case 4: t = e_key[3]; for(i = 0; i < 10; ++i) { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; t ^= e_key[4 * i]; e_key[4 * i + 4] = t; t ^= e_key[4 * i + 1]; e_key[4 * i + 5] = t; t ^= e_key[4 * i + 2]; e_key[4 * i + 6] = t; t ^= e_key[4 * i + 3]; e_key[4 * i + 7] = t; } break; case 6: LITTLE_B2D(&(UserKey[16]), e_key[4]); LITTLE_B2D(&(UserKey[20]), e_key[5]); t = e_key[5]; for(i = 0; i < 8; ++i) { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; t ^= e_key[6 * i]; e_key[6 * i + 6] = t; t ^= e_key[6 * i + 1]; e_key[6 * i + 7] = t; t ^= e_key[6 * i + 2]; e_key[6 * i + 8] = t; t ^= e_key[6 * i + 3]; e_key[6 * i + 9] = t; t ^= e_key[6 * i + 4]; e_key[6 * i + 10] = t; t ^= e_key[6 * i + 5]; e_key[6 * i + 11] = t; } // loop6(i); break; case 8: LITTLE_B2D(&(UserKey[16]), e_key[4]); LITTLE_B2D(&(UserKey[20]), e_key[5]); LITTLE_B2D(&(UserKey[24]), e_key[6]); LITTLE_B2D(&(UserKey[28]), e_key[7]); t = e_key[7]; for(i = 0; i < 7; ++i) { t = ls_box(rotr(t, 8)) ^ rco_tab[i]; t ^= e_key[8 * i]; e_key[8 * i + 8] = t; t ^= e_key[8 * i + 1]; e_key[8 * i + 9] = t; t ^= e_key[8 * i + 2]; e_key[8 * i + 10] = t; t ^= e_key[8 * i + 3]; e_key[8 * i + 11] = t; t = e_key[8 * i + 4] ^ ls_box(t); e_key[8 * i + 12] = t; t ^= e_key[8 * i + 5]; e_key[8 * i + 13] = t; t ^= e_key[8 * i + 6]; e_key[8 * i + 14] = t; t ^= e_key[8 * i + 7]; e_key[8 * i + 15] = t; } // loop8(i); break; } } /*************** Function ************************************************* * */ RET_VAL AES_EncKeySchedule( BYTE *UserKey, // 荤侩磊 厚剐虐 涝仿 DWORD UserKeyLen, // 荤侩磊 厚剐虐狼 官捞飘 荐 AES_ALG_INFO *AlgInfo) // 鞠龋侩/汗龋侩 Round Key 积己/历厘 { RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey; DWORD *e_key=RK_Struct->RK; // 64 DWORDs DWORD k_len; // UserKey狼 辨捞啊 何利例茄 版快 error 贸府 if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) ) return CTR_INVALID_USERKEYLEN; //// k_len = (UserKeyLen + 3) / 4; RK_Struct->k_len = k_len; RIJNDAEL_KeySchedule(UserKey, k_len, e_key); return CTR_SUCCESS; } /*************** Function ************************************************* * */ RET_VAL AES_DecKeySchedule( BYTE *UserKey, // 荤侩磊 厚剐虐 涝仿 DWORD UserKeyLen, // 荤侩磊 厚剐虐狼 官捞飘 荐 AES_ALG_INFO *AlgInfo) // 鞠龋侩/汗龋侩 Round Key 积己/历厘 { RIJNDAEL_CIPHER_KEY *RK_Struct=(RIJNDAEL_CIPHER_KEY *) AlgInfo->RoundKey; DWORD *d_key=RK_Struct->RK; // 64 DWORDs DWORD k_len, t_key[64]; u4byte i, t, u, v, w; // UserKey狼 辨捞啊 何利例茄 版快 error 贸府 if( (UserKeyLen!=16) && (UserKeyLen!=24) && (UserKeyLen!=32) ) return CTR_INVALID_USERKEYLEN; //// k_len = (UserKeyLen + 3) / 4; RK_Struct->k_len = k_len; RIJNDAEL_KeySchedule(UserKey, k_len, t_key); d_key[0] = t_key[4 * k_len + 24]; d_key[1] = t_key[4 * k_len + 25]; d_key[2] = t_key[4 * k_len + 26]; d_key[3] = t_key[4 * k_len + 27]; for( i=4; i<4*(k_len+6); i+=4) { imix_col(d_key[i+0], t_key[4*k_len+24-i+0]); imix_col(d_key[i+1], t_key[4*k_len+24-i+1]); imix_col(d_key[i+2], t_key[4*k_len+24-i+2]); imix_col(d_key[i+3], t_key[4*k_len+24-i+3]); } d_key[i+0] = t_key[4*k_len+24-i+0]; d_key[i+1] = t_key[4*k_len+24-i+1]; d_key[i+2] = t_key[4*k_len+24-i+2]; d_key[i+3] = t_key[4*k_len+24-i+3]; return CTR_SUCCESS; } /* DWORD A, B, C, D, T0, T1, *K=AlgInfo->RoundKey; //// if( UserKeyLen!=SEED_USER_KEY_LEN ) return CTR_INVALID_USERKEYLEN; //// BIG_B2D( &(UserKey[0]), A); BIG_B2D( &(UserKey[4]), B); BIG_B2D( &(UserKey[8]), C); BIG_B2D( &(UserKey[12]), D); T0 = A + C - KC0; T1 = B - D + KC0; K[0] = SEED_SL[0][(T0 )&0xFF] ^ SEED_SL[1][(T0>> 8)&0xFF] ^ SEED_SL[2][(T0>>16)&0xFF] ^ SEED_SL[3][(T0>>24)&0xFF]; K[1] = SEED_SL[0][(T1 )&0xFF] ^ SEED_SL[1][(T1>> 8)&0xFF] ^ SEED_SL[2][(T1>>16)&0xFF] ^ SEED_SL[3][(T1>>24)&0xFF];; EncRoundKeyUpdate0(K+ 2, A, B, C, D, KC1 ); EncRoundKeyUpdate1(K+ 4, A, B, C, D, KC2 ); EncRoundKeyUpdate0(K+ 6, A, B, C, D, KC3 ); EncRoundKeyUpdate1(K+ 8, A, B, C, D, KC4 ); EncRoundKeyUpdate0(K+10, A, B, C, D, KC5 ); EncRoundKeyUpdate1(K+12, A, B, C, D, KC6 ); EncRoundKeyUpdate0(K+14, A, B, C, D, KC7 ); EncRoundKeyUpdate1(K+16, A, B, C, D, KC8 ); EncRoundKeyUpdate0(K+18, A, B, C, D, KC9 ); EncRoundKeyUpdate1(K+20, A, B, C, D, KC10); EncRoundKeyUpdate0(K+22, A, B, C, D, KC11); EncRoundKeyUpdate1(K+24, A, B, C, D, KC12); EncRoundKeyUpdate0(K+26, A, B, C, D, KC13); EncRoundKeyUpdate1(K+28, A, B, C, D, KC14); EncRoundKeyUpdate0(K+30, A, B, C, D, KC15); // Remove sensitive data A = B = C = D = T0 = T1 = 0; K = NULL; // return CTR_SUCCESS; */ /*************** Macros ***************************************************/ #define f_nround(bo, bi, k) { / bo[0] = ft_tab[0][byte(bi[0],0)] / ^ ft_tab[1][byte(bi[1],1)] / ^ ft_tab[2][byte(bi[2],2)] / ^ ft_tab[3][byte(bi[3],3)] ^ k[0];/ bo[1] = ft_tab[0][byte(bi[1],0)] / ^ ft_tab[1][byte(bi[2],1)] / ^ ft_tab[2][byte(bi[3],2)] / ^ ft_tab[3][byte(bi[0],3)] ^ k[1];/ bo[2] = ft_tab[0][byte(bi[2],0)] / ^ ft_tab[1][byte(bi[3],1)] / ^ ft_tab[2][byte(bi[0],2)] / ^ ft_tab[3][byte(bi[1],3)] ^ k[2];/ bo[3] = ft_tab[0][byte(bi[3],0)] / ^ ft_tab[1][byte(bi[0],1)] / ^ ft_tab[2][byte(bi[1],2)] / ^ ft_tab[3][byte(bi[2],3)] ^ k[3];/ k += 4; / } #define i_nround(bo, bi, k) { / bo[0] = it_tab[0][byte(bi[0],0)] / ^ it_tab[1][byte(bi[3],1)] / ^ it_tab[2][byte(bi[2],2)] / ^ it_tab[3][byte(bi[1],3)] ^ k[0];/ bo[1] = it_tab[0][byte(bi[1],0)] / ^ it_tab[1][byte(bi[0],1)] / ^ it_tab[2][byte(bi[3],2)] / ^ it_tab[3][byte(bi[2],3)] ^ k[1];/ bo[2] = it_tab[0][byte(bi[2],0)] / ^ it_tab[1][byte(bi[1],1)] / ^ it_tab[2][byte(bi[0],2)] / ^ it_tab[3][byte(bi[3],3)] ^ k[2];/ bo[3] = it_tab[0][byte(bi[3],0)] / ^ it_tab[1][byte(bi[2],1)] / ^ it_tab[2][byte(bi[1],2)] / ^ it_tab[3][byte(bi[0],3)] ^ k[3];/ k += 4; / } #ifdef LARGE_TABLES #define f_lround(bo, bi, k) { / bo[0] = fl_tab[0][byte(bi[0],0)] / ^ fl_tab[1][byte(bi[1],1)] / ^ fl_tab[2][byte(bi[2],2)] / ^ fl_tab[3][byte(bi[3],3)] ^ k[0];/ bo[1] = fl_tab[0][byte(bi[1],0)] / ^ fl_tab[1][byte(bi[2],1)] / ^ fl_tab[2][byte(bi[3],2)] / ^ fl_tab[3][byte(bi[0],3)] ^ k[1];/ bo[2] = fl_tab[0][byte(bi[2],0)] / ^ fl_tab[1][byte(bi[3],1)] / ^ fl_tab[2][byte(bi[0],2)] / ^ fl_tab[3][byte(bi[1],3)] ^ k[2];/ bo[3] = fl_tab[0][byte(bi[3],0)] / ^ fl_tab[1][byte(bi[0],1)] / ^ fl_tab[2][byte(bi[1],2)] / ^ fl_tab[3][byte(bi[2],3)] ^ k[3];/ } #define i_lround(bo, bi, k) { / bo[0] = il_tab[0][byte(bi[0],0)] / ^ il_tab[1][byte(bi[3],1)] / ^ il_tab[2][byte(bi[2],2)] / ^ il_tab[3][byte(bi[1],3)] ^ k[0];/ bo[1] = il_tab[0][byte(bi[1],0)] / ^ il_tab[1][byte(bi[0],1)] / ^ il_tab[2][byte(bi[3],2)] / ^ il_tab[3][byte(bi[2],3)] ^ k[1];/ bo[2] = il_tab[0][byte(bi[2],0)] / ^ il_tab[1][byte(bi[1],1)] / ^ il_tab[2][byte(bi[0],2)] / ^ il_tab[3][byte(bi[3],3)] ^ k[2];/ bo[3] = il_tab[0][byte(bi[3],0)] / ^ il_tab[1][byte(bi[2],1)] / ^ il_tab[2][byte(bi[1],2)] / ^ il_tab[3][byte(bi[0],3)] ^ k[3];/ } #else #define f_rl(bo, bi, n, k) / bo[n] = (u4byte)sbx_tab[byte(bi[n],0)] ^ / rotl(((u4byte)sbx_tab[byte(bi[(n + 1) & 3],1)]), 8) ^ / rotl(((u4byte)sbx_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ / rotl(((u4byte)sbx_tab[byte(bi[(n + 3) & 3],3)]), 24) ^ *(k + n) #define i_rl(bo, bi, n, k) / bo[n] = (u4byte)isb_tab[byte(bi[n],0)] ^ / rotl(((u4byte)isb_tab[byte(bi[(n + 3) & 3],1)]), 8) ^ / rotl(((u4byte)isb_tab[byte(bi[(n + 2) & 3],2)]), 16) ^ / rotl(((u4byte)isb_tab[byte(bi[(n + 1) & 3],3)]), 24) ^ *(k + n) #define f_lround(bo, bi, k) / f_rl(bo, bi, 0, k); / f_rl(bo, bi, 1, k); / f_rl(bo, bi, 2, k); / f_rl(bo, bi, 3, k) #define i_lround(bo, bi, k) / i_rl(bo, bi, 0, k); / i_rl(bo, bi, 1, k); / i_rl(bo, bi, 2, k); / i_rl(bo, bi, 3, k) #endif /*************** Function ************************************************* * */ void AES_Encrypt( void *CipherKey, // 鞠/汗龋侩 Round Key BYTE *Data) // 涝免仿阑 困茄 喉废阑 啊府虐绰 pointer { RIJNDAEL_CIPHER_KEY *RK_Struct=CipherKey; DWORD *e_key=RK_Struct->RK; // 64 DWORDs DWORD k_len=RK_Struct->k_len; u4byte b0[4], b1[4], *kp; LITTLE_B2D(&(Data[ 0]), b0[0]); LITTLE_B2D(&(Data[ 4]), b0[1]); LITTLE_B2D(&(Data[ 8]), b0[2]); LITTLE_B2D(&(Data[12]), b0[3]); // b0[0] ^= e_key[0]; b0[1] ^= e_key[1]; b0[2] ^= e_key[2]; b0[3] ^= e_key[3]; kp = e_key + 4; switch( k_len ) { case 8 : f_nround(b1, b0, kp); f_nround(b0, b1, kp); case 6 : f_nround(b1, b0, kp); f_nround(b0, b1, kp); case 4 : f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_lround(b0, b1, kp); } // LITTLE_D2B(b0[0], &(Data[ 0])); LITTLE_D2B(b0[1], &(Data[ 4])); LITTLE_D2B(b0[2], &(Data[ 8])); LITTLE_D2B(b0[3], &(Data[12])); } /*************** Function ************************************************* * */ void AES_Decrypt( void *CipherKey, // 鞠/汗龋侩 Round Key BYTE *Data) // 涝免仿阑 困茄 喉废阑 啊府虐绰 pointer { RIJNDAEL_CIPHER_KEY *RK_Struct=CipherKey; DWORD *d_key=RK_Struct->RK; // 64 DWORDs DWORD k_len=RK_Struct->k_len; u4byte b0[4], b1[4], *kp; LITTLE_B2D(&(Data[ 0]), b0[0]); LITTLE_B2D(&(Data[ 4]), b0[1]); LITTLE_B2D(&(Data[ 8]), b0[2]); LITTLE_B2D(&(Data[12]), b0[3]); // b0[0] ^= d_key[0]; b0[1] ^= d_key[1]; b0[2] ^= d_key[2]; b0[3] ^= d_key[3]; kp = d_key + 4; switch( k_len ) { case 8 : i_nround(b1, b0, kp); i_nround(b0, b1, kp); case 6 : i_nround(b1, b0, kp); i_nround(b0, b1, kp); case 4 : i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_lround(b0, b1, kp); } // LITTLE_D2B(b0[0], &(Data[ 0])); LITTLE_D2B(b0[1], &(Data[ 4])); LITTLE_D2B(b0[2], &(Data[ 8])); LITTLE_D2B(b0[3], &(Data[12])); } /*************** 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. }  

你可能感兴趣的:(AES加密解密算法的C代码实现)

  • python 读excel每行替换_Python脚本操作Excel实现批量替换功能 weixin_39646695 python读excel每行替换
    Python脚本操作Excel实现批量替换功能大家好，给大家分享下如何使用Python脚本操作Excel实现批量替换。使用的工具Openpyxl，一个处理excel的python库，处理excel，其实针对的就是WorkBook，Sheet，Cell这三个最根本的元素~明确需求原始excel如下我们的目标是把下面excel工作表的sheet1表页A列的内容“替换我吧”批量替换为B列的“我用来替换的
  • x86-64汇编语言训练程序与实战 十除以十等于一
    本文还有配套的精品资源，点击获取简介：汇编语言是一种低级语言，与机器代码紧密相关，特别适用于编写系统级代码及性能要求高的应用。nasm编译器是针对x86和x86-64架构的汇编语言编译器，支持多种语法风格和指令集。项目Euler提供数学和计算机科学问题，鼓励编程技巧应用，前100个问题的答案可共享。x86-64架构扩展了寄存器数量并引入新指令，提升了数据处理效率。学习汇编语言能够深入理解计算机底层
  • 男士护肤品哪个牌子好？十大男士护肤品排行榜 高省APP珊珊
    很多男生意识到护肤的必要性，开始着手护肤，但不知道该选哪个男士护肤品品牌使用好。目前市面上很多男士护肤品品牌，可谓琳琅满目，让人眼花缭乱。男士挑选护肤品时，根据自己皮肤需求去正规渠道挑选合适的知名护肤品比较放心靠谱。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入
  • 三菱PLC全套学习资料及应用手册 good2know
    本文还有配套的精品资源，点击获取简介：三菱PLC作为工业自动化领域的核心设备，其系列产品的学习和应用需要全面深入的知识。本次资料包为学习者提供从基础到进阶的全方位学习资源，包括各种型号PLC的操作手册、编程指南、软件操作教程以及实际案例分析，旨在帮助用户系统掌握PLC的编程语言、指令系统及在各类工业应用中的实施。1.三菱PLC基础知识入门1.1PLC的基本概念可编程逻辑控制器（PLC）是工业自动化
  • 2022-10-20 体力劳动者
    不因感觉稍纵即逝就不加记录。在女儿睡觉后我记下今天的小故事。接手新班级后，今天是第二次收到家长的感谢信（微信）。是我表扬次数最多的两位学生家长致来的感谢，他们明显感受到孩子自信、阳光了不少，写作业由被动变为了主动，家庭氛围也由鸡飞狗跳变成了其乐融融。在被顽皮的学生气得头晕之后，我感到了久违的价值感，责任感甚至使命感，我回复家长这样一句话：我们也需要家长的反馈好让我们的教育工作更有劲头。我也认识到，
  • 程翔授《评价一篇记叙文》 行吟斯基
    桂林十一中高一2中学生自读程老师学生文章板书课题师巡看。看完举手。问：它是记叙文。不商量。独立打分。学生评价打分。师：高低都正常，不受干扰。师巡，略评。打完举手。调查：分层次举手——高分先举手。最低分。最高95分。最低45分。女：差距太大！师：同一篇，相差55分。若是你的文章，愿落谁手？男：身临其境感觉。师：你有此经历？没也没关系。女：不优美……，结尾无升华……无感悟……师：辞藻不美？(师追问)男
  • 《玉骨遥》：大司命为什么不杀朱颜？原因没那么简单 windy天意晚晴
    《玉骨遥》里，朱颜就是时影的命劫之人。重明与时影早就知道，他们一直瞒着大司命，如今大司命也知道了真相。可是大司命却没有杀朱颜，而是给朱颜下了诛心咒，还说时影的命劫已经破了，真的如此吗？1、计划总是赶不上变化的大司命从目前剧情来说，大司命还不如时影，他信心十足的事情总会有纰漏。他不让时影见命劫之女，结果时影还是遇上了。他想让时影走火入魔，一心复仇，结果时影在朱颜的劝说下放下了仇恨。大司命让时影开山收
  • 移动端城市区县二级联动选择功能实现包 good2know
    本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
  • 日更006 终极训练营day3 懒cici
    人生创业课（2）今天的主题：学习方法一：遇到有用的书，反复读，然后结合自身实际，列践行清单，不要再写读书笔记思考这本书与我有什么关系，我在哪些地方能用到，之后我该怎么用方法二：读完书没映像怎么办?训练你的大脑，方法：每读完一遍书，立马合上书，做一场分享，几分钟都行对自己的学习要求太低，要逼自己方法三：学习深度不够怎么办？找到细分领域的榜样，把他们的文章、书籍、产品都体验一遍，成为他们的超级用户，向
  • 自律打卡第四天：比昨天进步一点点 花儿的念想
    今天新闻我们县城又确诊了一例，截止目前已经确诊的三例了，打开，看了一篇简友写的武汉的真实情况，有病住不了院，还没等到床位已经去世的消息，心里更加的难受，武汉尚且这样，如果是我们这没有高速没有火车的十八线的小县城发生这种情况，那情况将是更加的不堪设想，不敢想，唯有祈求灾难早点快去，平安才是最大的福气。突然觉得我的自律打卡，比昨天进步一点点。更希望疫情战争每一天都要比昨天好一点，希望一觉醒来听到的是好
  • 15个小技巧，让我的Windows电脑更好用了！ 曹元_
    01.桌面及文档处理第一部分的技巧，主要是围绕桌面的一些基本操作，包括主题设置、常用文档文件快捷打开的多种方式等等。主题换色默认情况下，我们的Win界面可能就是白色的文档界面，天蓝色的图表背景，说不出哪里不好看，但是就是觉得不够高级。imageimage说到高级感，本能第一反应就会和暗色模式联想起来，如果我们将整个界面换成黑夜模式的话，它会是这样的。imageimage更改主题颜色及暗色模式，我们
  • （二）SAP Group Reporting (GR) 核心子模块功能及数据流向架构解析
    数据如何从子公司流转到合并报表的全过程，即数据采集→合并引擎→报表输出，特别是HANA内存计算如何优化传统ETL瓶颈。SAPGroupReporting(GR)核心模块功能及数据流向的架构解析，涵盖核心组件、数据处理流程和关键集成点，适用于S/4HANA1809+版本：一、核心功能模块概览模块功能关键事务码/FioriApp数据采集(DataCollection)整合子公司财务数据（SAP/非SA
  • 9、汇编语言编程入门：从环境搭建到简单程序实现 神经网络酱 汇编语言MEPISGNU工具链
    汇编语言编程入门：从环境搭建到简单程序实现1.数据存储介质问题解决在处理数据存储时，若要使用MEPIS系统，需确保有其可访问的存储介质。目前，MEPIS无法向采用NTFS格式（常用于Windows2000和XP工作站）的硬盘写入数据。不过，若硬盘采用FAT32格式，MEPIS就能进行写入操作。此外，MEPIS还能将文件写入软盘和大多数USB闪存驱动器。若工作站连接到局域网，还可通过FTP协议或挂载
  • 月光下的罪恶（5） 允歌玖沐
    5.被孤立顾纨是转校过来的，进入学校后，回头率很高“诶诶诶，你看那女生，哪个系的？”“不知道没见过。”“看那样，一看就是个胆小的货。”顾纨当做没听到，更狠的话她都听过，更何况女生们耍心眼？“他爸爸是做黑生意的，估计女儿也不是什么好的，你以后离他一家子远点。”她走向自己要上课的教室，一进门，所有人的目光看向她，顾纨若无其事的走进教室，开始上课。下课，一群人站起来，但是很显然，她周围的一圈人都不愿意和
  • day15｜前端框架学习和算法 universe_01 前端算法笔记
    T22括号生成先把所有情况都画出来，然后（在满足什么情况下）把不符合条件的删除。T78子集要画树状图，把思路清晰。可以用暴力法、回溯法和DFS做这个题DFS深度搜索：每个边都走完，再回溯应用：二叉树搜索，图搜索回溯算法=DFS+剪枝T200岛屿数量（非常经典BFS宽度把树状转化成队列形式，lambda匿名函数“一次性的小函数，没有名字”setup语法糖：让代码更简洁好写的语法ref创建：基本类型的
  • 贝多芬诞辰250周年纪念 万千星河赴远方
    就算不是古典音乐爱好者，你也一定听说过贝多芬。作为古典音乐史上最伟大的音乐家之一，他不仅是古典主义风格的集大成者，同时也是浪漫主义风格的开创者。贝多芬肖像画（1813年）贝多芬的一生共创作了9部交响曲、36首钢琴奏鸣曲、10部小提琴奏鸣曲、16首弦乐四重奏、1部歌剧及2部弥撒曲等等。数量虽然不及前辈海顿、莫扎特多，但他几乎改造了当时所有的音乐表达形式，赋予了它们全新的价值，对后世音乐的发展产生了极
  • IK分词 初心myp
    实现简单的分词功能，智能化分词添加依赖配置：4.10.4org.apache.lucenelucene-core${lucene.version}org.apache.lucenelucene-analyzers-common${lucene.version}org.apache.lucenelucene-queryparser${lucene.version}org.apache.lucenel
  • 三件事—小白猫·雨天·八段锦 咸鱼月亮
    1.最近楼下出现一只非常漂亮的粘人小白猫，看着不像是流浪猫，非常亲人。眼睛比蓝球的还大，而且是绿色的，很漂亮。第一次遇到它，它就跟我到电梯口，如果我稍微招招手，肯定就跟我进电梯了。后来我喂过它几次，好可惜不能养它，一只蓝球就是我的极限了。2.下雨天就心烦，好奇怪。明明以前我超爱看窗外的雨和听雨声，看来近来的心情不够宁静了。3.最近在练八段锦，从第一次就爱上了这个运动，很轻松缓慢，但是却出汗。感觉可
  • 25-1-2019 树藤与海岛呢
    hello八月来报道了今天看到了一篇文章就只想记下那两句话：良田千顷不过一日三餐广夏万间只睡卧榻三尺大概的意思就是要珍惜当下不要等来不及的时候才珍惜分享今天的两餐最近没有时间运动呢下个月补回好了说完了哈哈goodnight图片发自App图片发自App
  • 《极简思维》第三部分 小洋苏兮
    整理你的人际关系如何改善人际关系？摘录：因为人际关系问题是人们生活中不快乐的主要原因。感想：感觉这个说的挺对，之前我总是埋头学习，不管舍友不管自己的合作伙伴的一些事情，但实际上，这学期关注了之后好多了摘录：“亲密关系与社交会让你健康而快乐。这是基础。太过于关注成就或不太关心人际关系的人都不怎么快乐。基本上来说，人类就是建立在人脉关系上的。”感想：但是如果有时想的太多就不太好，要以一个开放的心态跟别
  • 力扣热题100-------54. 螺旋矩阵 海航Java之路 力扣leetcode矩阵java
    给你一个m行n列的矩阵matrix，请按照顺时针螺旋顺序，返回矩阵中的所有元素。示例1：输入：matrix=[[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例2：输入：matrix=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]提示：m==matrix.lengthn
  • 我不懂什么是爱，但我给你全部我拥有的 香尧
    因为怕黑，所以愿意陪伴在夜中行走的人，给他一点点的安全感。因为渴望温柔与爱，所以愿意为别的孩子付出爱与温柔。因为曾遭受侮辱和伤害，所以不以同样的方式施于其他人。如果你向别人出之以利刃，对方还了你爱与包容，真的不要感激他，真的不要赞美他。每一个被人伤害过的人心里都留下了一颗仇恨的种子，他也会想要有一天以眼还眼，以牙还牙。但他未让那颗种子生根发芽，他用一把心剑又一次刺向他自己，用他血荐仇恨，开出一朵温
  • 你要记住，最重要的是:随时做好准备，为了你可能成为更好的自己，放弃现在的自己。 霖霖z
    打卡人:周云日期:2018年11月09日【日精进打卡第180天】【知～学习】《六项精进》0遍共214遍《通篇》1遍共106遍《大学》2遍共347遍《坚强工作，温柔生活》ok《不抱怨的世界》104-108页《经典名句》你要记住，最重要的是:随时做好准备，为了你可能成为更好的自己，放弃现在的自己。【行～实践】一、修身：（对自己个人）1、坚持打卡二、齐家：（对家庭和家人）打扫卫生，接送孩子，洗衣做饭，陪
  • SpringMVC执行流程（原理），通俗易懂 国服冰 SpringMVCspringmvc
    SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
  • centos7出现 bash: ip: command not found 微信圈 centos
    centos7出现bash:ip:commandnotfoundyum-yinstallinitscripts
  • C++ 计数排序、归并排序、快速排序 每天搬一点点砖 c++数据结构算法
    计数排序：是一种基于哈希的排序算法。他的基本思想是通过统计每个元素的出现次数，然后根据统计结果将元素依次放入排序后的序列中。这种排序算法适用于范围较小的情况，例如整数范围在0到k之间计数排序步骤：1初始化一个长度为最大元素值加1的计数数组，所有元素初始化为02遍历原始数组，将每个元素值作为索引，在计数数组中对应位置加13将数组清空4遍历计数器数组，按照数组中的元素个数放回到元数组中计数排序的优点和
  • 现在发挥你的优势 爱生活的佑嘉
    来和我做咨询的一些朋友，涉及到定位的，都会说，我不知道我的优势是什么，你能不能帮我看看？还有一些朋友，喜欢做各种测试来了解自己，测试过后，然并卵。今天，我想来聊聊优势，如何能了解自己的优势是什么。首先，我们要知道，如果要成为“不一般”的人，我们所做的事情，就要基于自身的优势。我做管理者十多年，看到每个员工都有不同的特长，有的擅长数字，有的擅长人际，有的擅长写作。这些知道自己优势并且在这方面刻意练习
  • 2023-11-02 一帆f
    发现浸润心田的感觉：今天一个机缘之下突然想分享我的婆媳关系，我一边分享一边回忆我之前和儿媳妇关系的微妙变化，特别是分享到我能感受到儿媳妇的各种美好，现在也能心平气和的和老公平等对话，看到自己看到老公，以己推人以人推己自然而然的换位思考，心中有一种美好的能量在涌动，一种浸润心田的感觉从心胸向全身扩散，美好极了……我很想记住这种感觉，赶紧把它写下来以留纪念，也就是当我看见他人的美好，美好的美妙的浸润心
  • 贫穷家庭的孩子考上985以后会怎样？ Mellisa蜜思言
    我出生在一个贫穷的农村家庭，据我妈说，我出生的时候才4斤多，而她生完我以后月子里就瘦到70斤。家里一直很穷，父母都是在菜市场卖菜的，家里还有几亩地种庄稼的。我很小开始就要去帮忙，暑假的生活就是帮忙去卖菜和割稻谷，那时候自己对于割稻谷这种事情有着莫名的恐惧，生怕自己长大以后还是每年都要过着割稻谷这种日子。父母因为忙于生计无暇顾及我的学习，幸好我因为看到他们这样子的生活，内心里有深深的恐惧感，驱使着我
  • 实时数据流计算引擎Flink和Spark剖析 程小舰 flinkspark数据库kafkahadoop
    在过去几年，业界的主流流计算引擎大多采用SparkStreaming，随着近两年Flink的快速发展，Flink的使用也越来越广泛。与此同时，Spark针对SparkStreaming的不足，也继而推出了新的流计算组件。本文旨在深入分析不同的流计算引擎的内在机制和功能特点，为流处理场景的选型提供参考。（DLab数据实验室w.x.公众号出品）一.SparkStreamingSparkStreamin
  • Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
  • maven依赖范围 bitcarter maven
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
  • Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
  • CSS Specificity 周凡杨 html权重Specificitycss
      有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
  • java与servlet g21121 servlet
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
  • eclipse中安装maven插件 510888780 eclipsemaven
    1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
  • jpa@OneToOne关联关系 布衣凌宇 jpa
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
  • 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
  • java 动态代理简单实现 antlove javahandlerproxydynamicservice
    dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
  • JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
             如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
  • 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
    MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
  • 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
    public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
  • 看博客，应该是有方向的 Cb123456 反省看博客
    看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
         为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
  • Hibernat and Ibatis dashuaifu Hibernateibatis
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
  • 备份MYSQL脚本 dcj3sjt126com mysql
    #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
  • iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
    转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
  • html wlwmanifest.xml eoems htmlxml
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
  • 浅谈Java定时器发展 hacksin java并发timer定时器
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
  • 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
  • AspectJ+Javasist记录日志 kane_xie aspectjjavasist
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
  • redis学习笔记 MJC410621 redisNoSQL
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
  • 使用redis实现分布式锁 qifeifei
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
  • BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
    1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他