zoukankan      html  css  js  c++  java

  • QQ通讯协议里的TEA加解密算法

    1. #include <stdio.h> 
    2. #include <stdlib.h> 
    3. #include <memory.h> 
    4. #include <string.h> 
    5. #include <time.h> 
    6.   
    7. //#define CRYPT_ONE_BYTE 
    8.   
    9. typedef char int8 ; 
    10. typedef unsigned char uint8 ; 
    11. typedef short int16 ; 
    12. typedef unsigned short uint16 ; 
    13. typedef long int32 ; 
    14. typedef unsigned long uint32 ; 
    15.   
    16. typedef struct tagTEACTX 
    17. { 
    18.     uint8 buf[8] ; 
    19.     uint8 bufPre[8] ; 
    20.     const uint8 *pKey ; //指向16字节的key  
    21.     uint8 *pCrypt ; 
    22.     uint8 *pCryptPre ; 
    23. } TEACTX, *LPTEACTX ; 
    24.   
    25. uint16 Host2NetShort(uint16 usHost) 
    26. { 
    27.     const uint16 us = 0x1234 ; 
    28.     return ((uint8 *)&us)[0] == 0x12 ? usHost : ((usHost>>8) | (usHost<<8)) ; 
    29. } 
    30.   
    31. uint16 Net2HostShort(uint16 usNet) 
    32. { 
    33.     return Host2NetShort(usNet) ; 
    34. } 
    35.   
    36. uint32 Host2NetLong(uint32 ulHost) 
    37. { 
    38.     const uint16 us = 0x1234 ; 
    39.     return ((uint8 *)&us)[0] == 0x12 ? ulHost : (((ulHost>>8) & 0xFF00) |  
    40.         ((ulHost<<8) & 0xFF0000) | (ulHost<<24) | (ulHost>>24)) ; 
    41. } 
    42.   
    43. uint32 Net2HostLong(uint32 ulHost) 
    44. { 
    45.     return Host2NetLong(ulHost) ; 
    46. } 
    47.   
    48. //TEA加密。v明文8字节。k密钥16字节。w密文输出8字节。  
    49. void EnCipher(const uint32 *const v, const uint32 *const k, uint32 *const w) 
    50. { 
    51.     register uint32  
    52.         y     = Host2NetLong(v[0]), 
    53.         z     = Host2NetLong(v[1]), 
    54.         a     = Host2NetLong(k[0]), 
    55.         b     = Host2NetLong(k[1]), 
    56.         c     = Host2NetLong(k[2]), 
    57.         d     = Host2NetLong(k[3]), 
    58.         n     = 0x10,       /* do encrypt 16 (0x10) times */ 
    59.         sum   = 0, 
    60.         delta = 0x9E3779B9; /*  0x9E3779B9 - 0x100000000 = -0x61C88647 */ 
    61.   
    62.     while (n-- > 0) 
    63.     { 
    64.         sum += delta; 
    65.         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b); 
    66.         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d); 
    67.     } 
    68.   
    69.     w[0] = Net2HostLong(y); 
    70.     w[1] = Net2HostLong(z); 
    71. } 
    72.   
    73. //TEA解密。v密文8字节。k密钥16字节。w明文输出8字节。  
    74. void DeCipher(const uint32 *const v, const uint32 *const k, uint32 *const w) 
    75. { 
    76.     register uint32 
    77.         y     = Host2NetLong(v[0]), 
    78.         z     = Host2NetLong(v[1]), 
    79.         a     = Host2NetLong(k[0]), 
    80.         b     = Host2NetLong(k[1]), 
    81.         c     = Host2NetLong(k[2]), 
    82.         d     = Host2NetLong(k[3]), 
    83.         n     = 0x10, 
    84.         sum   = 0xE3779B90,  
    85.         /* why this ? must be related with n value*/ 
    86.         delta = 0x9E3779B9; 
    87.   
    88.     /* sum = delta<<5, in general sum = delta * n */ 
    89.     while (n-- > 0) 
    90.     { 
    91.         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d); 
    92.         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b); 
    93.         sum -= delta; 
    94.     } 
    95.   
    96.     w[0] = Net2HostLong(y); 
    97.     w[1] = Net2HostLong(z); 
    98. } 
    99.   
    100. uint32 Random(void) 
    101. { 
    102.     return (uint32)rand(); 
    103.     //return 0xdead ; 
    104. } 
    105.   
    106. //每次8字节加密  
    107. static void EncryptEach8Bytes(TEACTX *pCtx) 
    108. { 
    109. #ifdef CRYPT_ONE_BYTE 
    110.     uint32 i ; 
    111.     uint8 *pPlain8, *pPlainPre8, *pCrypt8, *pCryptPre8 ; 
    112.     pPlain8 = (uint8 *)pCtx->buf ; 
    113.     pPlainPre8 = (uint8 *)pCtx->bufPre ; 
    114.     pCrypt8 = (uint8 *)pCtx->pCrypt ; 
    115.     pCryptPre8 = (uint8 *)pCtx->pCryptPre ; 
    116.     //本轮明文与上一轮的密文异或  
    117.     for(i=0; i<8; i++) 
    118.         pPlain8[i] ^= pCryptPre8[i] ; 
    119.     //再对异或后的明文加密  
    120.     EnCipher((uint32 *)pPlain8, (uint32 *)pCtx->pKey, (uint32 *)pCrypt8) ; 
    121.     //将加密后的密文与上一轮的明文(其实是上一轮明文与上上轮密文异或结果)异或 
    122.     for(i=0; i<8; i++) 
    123.         pCrypt8[i] ^= pPlainPre8[i] ; 
    124.     // 
    125.     for(i=0; i<8; i++) 
    126.         pPlainPre8[i] = pPlain8[i] ; 
    127. #else 
    128.     uint32 *pPlain8, *pPlainPre8, *pCrypt8, *pCryptPre8 ; 
    129.     pPlain8 = (uint32 *)pCtx->buf ; 
    130.     pPlainPre8 = (uint32 *)pCtx->bufPre ; 
    131.     pCrypt8 = (uint32 *)pCtx->pCrypt ; 
    132.     pCryptPre8 = (uint32 *)pCtx->pCryptPre ; 
    133.     pPlain8[0] ^= pCryptPre8[0] ; 
    134.     pPlain8[1] ^= pCryptPre8[1] ; 
    135.     EnCipher(pPlain8, (const uint32 *)pCtx->pKey, pCrypt8) ; 
    136.     pCrypt8[0] ^= pPlainPre8[0] ; 
    137.     pCrypt8[1] ^= pPlainPre8[1] ; 
    138.     pPlainPre8[0] = pPlain8[0] ; 
    139.     pPlainPre8[1] = pPlain8[1] ; 
    140. #endif 
    141.     pCtx->pCryptPre = pCtx->pCrypt ; 
    142.     pCtx->pCrypt += 8 ; 
    143. } 
    144.   
    145. //加密。pPlain指向待加密的明文。ulPlainLen明文长度。pKey密钥16字节。 
    146. //pOut指向密文输出缓冲区。pOutLen输入输出参数，指示输出缓冲区长度、密文长度。  
    147. uint32 Encrypt(TEACTX *pCtx, const uint8 *pPlain, uint32 ulPlainLen,  
    148.     const uint8 *pKey, uint8 *pOut, uint32 *pOutLen) 
    149. { 
    150.     uint32 ulPos, ulPadding, ulOut ; 
    151.     const uint8 *p ; 
    152.     if(pPlain == NULL || ulPlainLen == 0 || pOutLen == NULL) 
    153.         return 0 ; 
    154.     //计算需要填充的字节数 
    155.     //整个加密流程下来，不管明文长度多少，填充10个字节是固定的， 
    156.     //然后再根据明文的长度计算还需要填充的字节数。  
    157.     ulPos = (8 - ((ulPlainLen + 10) & 0x07)) & 0x07 ; 
    158.     //计算加密后的长度 
    159.     ulOut = 1 + ulPos + 2 + ulPlainLen + 7 ; 
    160.     if(*pOutLen < ulOut) 
    161.     { 
    162.         *pOutLen = ulOut ; 
    163.         return 0 ; 
    164.     } 
    165.     *pOutLen = ulOut ; 
    166.     memset(pCtx, 0, sizeof(TEACTX)) ; 
    167.     pCtx->pCrypt = pOut ; 
    168.     pCtx->pCryptPre = pCtx->bufPre ; 
    169.     pCtx->pKey = pKey ; 
    170.     //buf[0]的最低3bit位等于所填充的长度 
    171.     pCtx->buf[0] = (uint8)((Random() & 0xF8) | ulPos) ; 
    172.     //用随机数填充上面计算得到的填充长度(每个字节填充的内容是一样的)。 
    173.     //这里填充的起始位置是&buf[1]。 
    174.     memset(pCtx->buf+1, (uint8)Random(), ulPos++) ; 
    175.     //至少再填充两字节 
    176.     for(ulPadding=0; ulPadding<2; ulPadding++) 
    177.     { 
    178.         if(ulPos == 8) 
    179.         { 
    180.             EncryptEach8Bytes(pCtx) ; 
    181.             ulPos = 0 ; 
    182.         } 
    183.         pCtx->buf[ulPos++] = (uint8)Random() ; 
    184.     } 
    185.     p = pPlain ; 
    186.     while(ulPlainLen > 0) 
    187.     { 
    188.         if(ulPos == 8) 
    189.         { 
    190.             EncryptEach8Bytes(pCtx) ; 
    191.             ulPos = 0 ; 
    192.         } 
    193.         pCtx->buf[ulPos++] = *(p++) ; 
    194.         ulPlainLen-- ; 
    195.     } 
    196.     //末尾再添加7字节0后加密，在解密过程的时候可以用来判断key是否正确。  
    197.     for(ulPadding=0; ulPadding<7; ulPadding++) 
    198.         pCtx->buf[ulPos++] = 0x00 ; 
    199.     // 
    200.     EncryptEach8Bytes(pCtx) ; 
    201.     return ulOut ; 
    202. } 
    203.   
    204. //每次8字节进行解密  
    205. static void DecryptEach8Bytes(TEACTX *pCtx) 
    206. { 
    207. #ifdef CRYPT_ONE_BYTE 
    208.     uint32 i ; 
    209.     uint8 bufTemp[8] ; 
    210.     uint8 *pBuf8, *pBufPre8, *pCrypt8, *pCryptPre8 ; 
    211.     pBuf8 = (uint8 *)pCtx->buf ; 
    212.     pBufPre8 = (uint8 *)pCtx->bufPre ; 
    213.     pCrypt8 = (uint8 *)pCtx->pCrypt ; 
    214.     pCryptPre8 = (uint8 *)pCtx->pCryptPre ; 
    215.     //当前的密文与前一轮明文(实际是前一轮明文与前前轮密文异或结果)异或  
    216.     for(i=0; i<8; i++) 
    217.         bufTemp[i] = pCrypt8[i] ^ pBufPre8[i] ; 
    218.     //异或后的结果再解密(解密后得到当前名文与前一轮密文异或的结果，并非真正明文) 
    219.     DeCipher((uint32 *)bufTemp, (uint32 *)pCtx->pKey, (uint32 *)pBufPre8) ; 
    220.     //解密后的结果与前一轮的密文异或，得到真正的明文  
    221.     for(i=0; i<8; i++) 
    222.         pBuf8[i] = pBufPre8[i] ^ pCryptPre8[i] ; 
    223. #else 
    224.     uint32 bufTemp[2] ; 
    225.     uint32 *pBuf8, *pBufPre8, *pCrypt8, *pCryptPre8 ; 
    226.     pBuf8 = (uint32 *)pCtx->buf ; 
    227.     pBufPre8 = (uint32 *)pCtx->bufPre ; 
    228.     pCrypt8 = (uint32 *)pCtx->pCrypt ; 
    229.     pCryptPre8 = (uint32 *)pCtx->pCryptPre ; 
    230.     bufTemp[0] = pCrypt8[0] ^ pBufPre8[0] ; 
    231.     bufTemp[1] = pCrypt8[1] ^ pBufPre8[1] ; 
    232.     DeCipher(bufTemp, (const uint32 *)pCtx->pKey, pBufPre8) ; 
    233.     pBuf8[0] = pBufPre8[0] ^ pCryptPre8[0] ; 
    234.     pBuf8[1] = pBufPre8[1] ^ pCryptPre8[1] ; 
    235. #endif 
    236.     pCtx->pCryptPre = pCtx->pCrypt ; 
    237.     pCtx->pCrypt += 8 ; 
    238. } 
    239.   
    240. //解密。pCipher指向待解密密文。ulCipherLen密文长度。pKey密钥16字节。 
    241. //pOut指向明文输出缓冲区。pOutLen输入输出参数，指示输出缓冲区长度、明文长度。  
    242. uint32 Decrypt(TEACTX *pCtx, const uint8 *pCipher, uint32 ulCipherLen,  
    243.     const uint8 *pKey, uint8 *pOut, uint32 *pOutLen) 
    244. { 
    245.     uint32 ulPos, ulPadding, ulOut, ul ; 
    246.     // 待解密的数据长度最少16字节，并且长度满足是8的整数倍。 
    247.     if(pCipher == NULL || pOutLen == NULL ||  
    248.             ulCipherLen < 16 || (ulCipherLen & 0x07) != 0) 
    249.         return 0 ; 
    250.     // 先解密头8字节，以便获取第一轮加密时填充的长度。 
    251.     DeCipher((const uint32 *)pCipher, (const uint32 *)pKey, (uint32 *)pCtx->bufPre) ; 
    252.     for(ul=0; ul<8; ul++) 
    253.         pCtx->buf[ul] = pCtx->bufPre[ul] ; 
    254.     ulPos = pCtx->buf[0] & 0x07 ; //第一轮加密时填充的长度 
    255.     if(ulPos > 1) 
    256.     { 
    257.         for(ulOut=2; ulOut<=ulPos; ulOut++) 
    258.         { 
    259.             if(pCtx->buf[1] != pCtx->buf[ulOut]) 
    260.             { 
    261.                 *pOutLen = 0 ; 
    262.                 return 0 ; //解密失败  
    263.             } 
    264.         } 
    265.     } 
    266.     ulOut = ulCipherLen - ulPos - 10 ; 
    267.     if(ulPos + 10 > ulCipherLen || *pOutLen < ulOut) 
    268.         return 0 ; 
    269.     pCtx->pCryptPre = (uint8 *)pCipher ; 
    270.     pCtx->pCrypt = (uint8 *)pCipher + 8 ; 
    271.     ulPos++ ; 
    272.     for(ulPadding=0; ulPadding<2; ulPadding++) 
    273.     { 
    274.         if(ulPos == 8) 
    275.         { 
    276.             DecryptEach8Bytes(pCtx) ; 
    277.             ulPos = 0 ; 
    278.         } 
    279.         ulPos++ ; 
    280.     } 
    281.     // 
    282.     for(ul=0; ul<ulOut; ul++) 
    283.     { 
    284.         if(ulPos == 8) 
    285.         { 
    286.             DecryptEach8Bytes(pCtx) ; 
    287.             ulPos = 0 ; 
    288.         } 
    289.         pOut[ul] = pCtx->buf[ulPos] ; 
    290.         ulPos++ ; 
    291.     } 
    292.     // 
    293.     for(ulPadding=0; ulPadding<7; ulPadding++) 
    294.     { 
    295.         if(ulPos < 8) 
    296.         { 
    297.             if(pCtx->buf[ulPos] != 0x00) 
    298.             { 
    299.                 *pOutLen = 0 ; 
    300.                 return 0 ; 
    301.             } 
    302.         } 
    303.         ulPos++ ; 
    304.     } 
    305.     *pOutLen = ulOut ; 
    306.     return 1 ; 
    307. } 
    308.   
    309. void PrintBuffer(const uint8 *buf, uint32 ulLen) 
    310. { 
    311.     uint32 i ; 
    312.     for(i=0; i<ulLen; i++) 
    313.     { 
    314.         printf("%.2X ", buf[i]) ; 
    315.         if((i+1) % 16 == 0) 
    316.             putchar(' ') ; 
    317.     } 
    318.     if((ulLen & 0x0F) != 0) 
    319.         putchar(' ') ; 
    320. } 
    321.   
    322. int main(void) 
    323. { 
    324.     const char *pPK[][2] =  
    325.     { 
    326.         //明文--密钥  
    327.         {"tea", "123456789abcdef"}, 
    328.         {"tea", "123456789abcdef"}, 
    329.         {"123456",  "password1234567"}, 
    330.         {"AABBCCD", "aabbccddeeffggh"}, 
    331.         {"Hello World 你好世界！", "aabbccddeeffggh"} 
    332.     } ; 
    333.     TEACTX ctx ; 
    334.     uint8 bufEnc[512], bufDec[512] ; 
    335.     uint32 ulEnc, ulDec, ulRet ; 
    336.     int i ; 
    337.     for(i=0; i<sizeof(pPK)/sizeof(pPK[0]); i++) 
    338.     { 
    339.         printf("明文：%s 密钥：%s ", pPK[i][0], pPK[i][1]) ; 
    340.         ulEnc = sizeof(bufEnc) ; 
    341.         Encrypt(&ctx, (const uint8 *)pPK[i][0], strlen(pPK[i][0])+1,  
    342.                 (const uint8 *)pPK[i][1], (uint8 *)bufEnc, &ulEnc) ; 
    343.         printf("密文： ") ; 
    344.         PrintBuffer(bufEnc, ulEnc) ; 
    345.         ulDec = sizeof(bufDec) ; 
    346.         ulRet = Decrypt(&ctx, bufEnc, ulEnc, (const uint8 *)pPK[i][1],  
    347.                 (uint8 *)bufDec, &ulDec) ; 
    348.         if(ulRet != 0) 
    349.             printf("解密后明文：%s ", bufDec) ; 
    350.         else 
    351.             printf("解密失败！ ") ; 
    352.         putchar(' ') ; 
    353.     } 
    354.     return 0 ; 
    355. } 
  • 相关阅读:
    C#中double转int时需要注意的地方
    OracleHelper类
    POJ2570, ZOJ1967
    ZOJ3088
    POJ3259(spfa判负环)
    POJ3268
    ZOJ1092 POJ2240
    ZOJ1298 POJ1135
    SRM587 div2
    POJ1679判断最小生成树是否唯一
  • 原文地址：https://www.cnblogs.com/zaiiiPan/p/4430039.html
Copyright © 2011-2022 走看看