QQTEA加密解密实现

分类： 加密算法 2013-11-14 11:40  1295人阅读  评论(0)  收藏  举报

本文从konglinglong的项目wingIM转载而来，使用者必须尊重原作者的著作权，在其授权范围内使用。中文注释为我所加，感谢原作者的辛勤劳动和无私共享精神！

wingIM发布在谷歌代码里，地址为：http://code.google.com/p/wingim/

crypt.h

 /**
  * The QQ2003C protocol plugin
  *
  * for gaim
  *
  * Copyright © 2004 Puzzlebird
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  **************************************************
  * Reorganized by Minmin , 2005-3-27
  **************************************************
  */

 #ifndef Crypt_H
 #define Crypt_H

 #define DECRYPT 0x00
 #define ENCRYPT 0x01

 #include "Wingdefines.h"

 class Crypt
 {
 public:
     Crypt();
     ~Crypt();

     static void encrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
                 unsigned char*  outstr, int32* outstrlen_ptr);

     static int decrypt(unsigned char* instr, int32 instrlen, unsigned char* key,
                 unsigned char*  outstr, int32* outstrlen_ptr);

 private:
     static int rand(void);
     static void teaEncipher(unsigned int *const v, const unsigned int *const k,
                 unsigned int *const w);
     static void teaDecipher(unsigned int *const v, const unsigned int *const k,
                 unsigned int *const w);

     static int qq_crypt ( unsigned char   flag,  unsigned char*  instr,  int32  instrlen,
                 unsigned char*  key, unsigned char*  outstr, int32* outstrlen_ptr);
 };

 #endif

crypt.cpp

 /**
  * The QQ2003C protocol plugin
  *
  * for gaim
  *
  * Copyright © 2004 Puzzlebird
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  **************************************************
  * Reorganized by Minmin , 2005-3-27
  **************************************************
  */

 #include "crypt.h"

 #include
 #ifdef _WIN32
 #include
 #else
 #include
 #endif
 #include

 Crypt::Crypt()
 {
 }

 Crypt::~Crypt()
 {
 }

 void Crypt::teaEncipher(unsigned int *const v, const unsigned int *const k,
             unsigned int *const w)
 {
     register unsigned int
         y     = ntohl(v[0]),
         z     = ntohl(v[1]),
         a     = ntohl(k[0]),
         b     = ntohl(k[1]),
         c     = ntohl(k[2]),
         d     = ntohl(k[3]),
         n     = 0x10,       /* do encrypt 16 (0x10) times */
         sum   = 0,
         delta = 0x9E3779B9; /*  0x9E3779B9 - 0x100000000 = -0x61C88647 */

     while (n-- > 0) {
         sum += delta;
         y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
         z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
     }

     w[0] = htonl(y); w[1] = htonl(z);
 }
 void Crypt::teaDecipher(unsigned int *const v, const unsigned int *const k,
             unsigned int *const w)
 {
     register unsigned int
         y     = ntohl(v[0]),
         z     = ntohl(v[1]),
         a     = ntohl(k[0]),
         b     = ntohl(k[1]),
         c     = ntohl(k[2]),
         d     = ntohl(k[3]),
         n     = 0x10,
         sum   = 0xE3779B90,
         /* why this ? must be related with n value*/
         delta = 0x9E3779B9;

     /* sum = delta<<5, in general sum = delta * n */
     while (n-- > 0) {
         z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
         y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
         sum -= delta;
     }

     w[0] = htonl(y); w[1] = htonl(z);
 }

 void Crypt::encrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
             unsigned char*  outstr, int32* outstrlen_ptr)
 {
     unsigned char
         plain[8],         /* plain text buffer*/
         plain_pre_8[8],   /* plain text buffer, previous 8 bytes*/
         * crypted,        /* crypted text*/
         * crypted_pre_8,  /* crypted test, previous 8 bytes*/
         * inp;            /* current position in instr*/
     int
         pos_in_byte = 1,  /* loop in the byte */
         is_header=1,      /* header is one byte*/
         count=0,          /* number of bytes being crypted*/
         padding = 0;      /* number of padding stuff*/

     //void encrypt_every_8_byte (void);


     /*** we encrypt every eight byte ***/
 #define encrypt_every_8_byte()  \
     {\
     for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {\
     if(is_header) { plain[pos_in_byte] ^= plain_pre_8[pos_in_byte]; }\
             else { plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte]; }\  //待加密单元等于明文与前面已加密的8字节异或（交织算法第一步）
     } /* prepare plain text*/\
     teaEncipher( (unsigned int *) plain,\
     (unsigned int *) key, \
     (unsigned int *) crypted);   /* encrypt it*/\        //TEA加密
     \
     for(pos_in_byte=0; pos_in_byte<8; pos_in_byte++) {\
     crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte]; \  //密文等于加密后的数据与前一单元待加密的数据异或 （交织算法第二步）
     } \
     memcpy(plain_pre_8, plain, 8);     /* prepare next*/\
     \
     crypted_pre_8   =   crypted;       /* store position of previous 8 byte*/\
     crypted         +=  8;             /* prepare next output*/\
     count           +=  8;             /* outstrlen increase by 8*/\
     pos_in_byte     =   0;             /* back to start*/\
     is_header       =   0;             /* and exit header*/\
     }/* encrypt_every_8_byte*/


     pos_in_byte = (instrlen + 0x0a) % 8; /* header padding decided by instrlen*/
     if (pos_in_byte) {
         pos_in_byte = 8 - pos_in_byte;  //求出要padding多少字节
     }
     plain[0] = (rand() & 0xf8) | pos_in_byte; //头部第一个字节

     memset(plain+1, rand()&0xff, pos_in_byte++); //padding n 个字节
     memset(plain_pre_8, 0x00, sizeof(plain_pre_8)); //前8个字节清零

     crypted = crypted_pre_8 = outstr;

     padding = 1; /* pad some stuff in header*/    //pad 2 bytes
     while (padding <= 2) { /* at most two byte */
         if(pos_in_byte < 8) { plain[pos_in_byte++] = rand() & 0xff; padding ++; }
         if(pos_in_byte == 8){ encrypt_every_8_byte(); }
     }

     inp = instr;
     while (instrlen > 0) {
         if (pos_in_byte < 8) { plain[pos_in_byte++] = *(inp++); instrlen --; } //复制明文至待加密数据区
         if (pos_in_byte == 8){ encrypt_every_8_byte(); } //满8个字节则加密
     }

     padding = 1; /* pad some stuff in tailer*/           //pad 7 bytes 00
     while (padding <= 7) { /* at most sever byte*/
         if (pos_in_byte < 8) { plain[pos_in_byte++] = 0x00; padding ++; }
         if (pos_in_byte == 8){ encrypt_every_8_byte(); }
     }

     *outstrlen_ptr = count;

 }

 int Crypt::rand(void)
 {
     /* it can be the real random seed function*/
     return 0xdead; /* override with number, convenient for debug*/
 }

 int Crypt::decrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
             unsigned char*  outstr, int32* outstrlen_ptr)
 {
     unsigned char
         decrypted[8], m[8],
         * crypt_buff,
         * crypt_buff_pre_8,
         * outp;
     int
         count,           //明文数据长度
         context_start,  //长度临时变量
         pos_in_byte,
         padding;

 #define decrypt_every_8_byte()  {\
     bool bNeedRet = false;\
     for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte ++ ) {\
         if (context_start + pos_in_byte >= instrlen) \
         {\
             bNeedRet = true;\
             break;\
         }\
         decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];\ //待解密单元等于前面已解密单元与下一个待解密单元异或
     }\
     if( !bNeedRet ) { \
         teaDecipher( (unsigned int *) decrypted, \
         (unsigned int *) key, \
         (unsigned int *) decrypted);\    //解密
     \
         context_start +=  8;\
         crypt_buff    +=  8;\
         pos_in_byte   =   0;\
     }\
 }/* decrypt_every_8_byte*/

     /* at least 16 bytes and %8 == 0*/
     if ((instrlen % 8) || (instrlen < 16)) return 0;
     /* get information from header*/
     teaDecipher( (unsigned int *) instr,
         (unsigned int *) key,
         (unsigned int *) decrypted);   //解出头部，然后decrypted缓冲区就有初值了
     pos_in_byte = decrypted[0] & 0x7;
     count = instrlen - pos_in_byte - 10; /* this is the plaintext length*/
     /* return if outstr buffer is not large enought or error plaintext length*/
     if (*outstrlen_ptr < count || count < 0) return 0;

     memset(m, 0, 8);
     crypt_buff_pre_8 = m;
     *outstrlen_ptr = count;   /* everything is ok! set return string length*/

     crypt_buff = instr + 8;   /* address of real data start */
     context_start = 8;        /* context is at the second 8 byte*/
     pos_in_byte ++;           /* start of paddng stuffv*/

     padding = 1;              /* at least one in header*/
     while (padding <= 2) {    /* there are 2 byte padding stuff in header*/
         if (pos_in_byte < 8) {  /* bypass the padding stuff, none sense data*/
             pos_in_byte ++; padding ++;
         }
         if (pos_in_byte == 8) {
             crypt_buff_pre_8 = instr;
             //if (! decrypt_every_8_byte()) return 0;
             decrypt_every_8_byte();
         }
     }/* while*/

     outp = outstr;
     while(count !=0) {
         if (pos_in_byte < 8) {
             *outp = crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]; //输出明文等于前一个密文单元数据异或当前解密后单元
             outp ++;
             count --;
             pos_in_byte ++;
         }
         if (pos_in_byte == 8) {
             crypt_buff_pre_8 = crypt_buff - 8;
             //if (! decrypt_every_8_byte()) return 0;
             decrypt_every_8_byte();
         }
     }/* while*/

     for (padding = 1; padding < 8; padding ++) {
         if (pos_in_byte < 8) {
             if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]) return 0; //若是和0异或的话则说明已解密完毕了
             pos_in_byte ++;
         }
         if (pos_in_byte == 8 ) {
             crypt_buff_pre_8 = crypt_buff;
             //if (! decrypt_every_8_byte()) return 0;
             decrypt_every_8_byte();
         }
     }/* for*/
     return 1;

 }


 int Crypt::qq_crypt ( unsigned char   flag,  unsigned char*  instr,  int32  instrlen,
             unsigned char*  key, unsigned char*  outstr, int32* outstrlen_ptr)
 {
     if (flag == DECRYPT)
         return decrypt(instr, instrlen, key, outstr, outstrlen_ptr);
     else
         if (flag == ENCRYPT)
             encrypt(instr, instrlen, key, outstr, outstrlen_ptr);

     return 1; /* flag must be DECRYPT or ENCRYPT*/
 }/* qq_crypt*/