﻿ Tea算法 - C++_C/C++代码_BlackFeather'S Blog

# Tea算法 - C++

Tea算法被某公司应用的酣畅淋漓，最近用到了，在测试了多分代码后，推荐此代码。保留原作者信息。

cpypt.cpp

```/**
* The QQ2003C protocol plugin
*
* for gaim
*
*
* 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 <csdengxm@hotmail.com>, 2005-3-27
**************************************************
*/

#include "stdafx.h"
#include "crypt.h"

#include <string.h>
#ifdef _WIN32
#include <winsock.h>
#else
#include <arpa/inet.h>
#endif
#include <cstring>

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),
z     = ntohl(v),
a     = ntohl(k),
b     = ntohl(k),
c     = ntohl(k),
d     = ntohl(k),
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 = htonl(y); w = htonl(z);
}
void Crypt::teaDecipher(unsigned int *const v, const unsigned int *const k,
unsigned int *const w)
{
register unsigned int
y     = ntohl(v),
z     = ntohl(v),
a     = ntohl(k),
b     = ntohl(k),
c     = ntohl(k),
d     = ntohl(k),
n     = 0x10,
sum   = 0xE3779B90,
/* why this ? must be related with n value*/
delta = 0x9E3779B9;

void *p = &a;
/* 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 = htonl(y);
w = htonl(z);
}

void Crypt::encrypt( unsigned char* instr, int32 instrlen, unsigned char* key,
unsigned char*  outstr, int32* outstrlen_ptr)
{
unsigned char
plain,         /* plain text buffer*/
plain_pre_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 */
count=0,          /* number of bytes being crypted*/

//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]; }\
} /* prepare plain text*/\
teaEncipher( (unsigned int *) plain,\
(unsigned int *) key, \
(unsigned int *) crypted);   /* encrypt it*/\
\
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*/\
}/* 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;
}
plain = (rand() & 0xf8) | pos_in_byte;

memset(plain+1, rand()&0xff, pos_in_byte++);
memset(plain_pre_8, 0x00, sizeof(plain_pre_8));

crypted = crypted_pre_8 = outstr;

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(); }
}

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, m,
* crypt_buff,
* crypt_buff_pre_8,
* outp;
int
count,
context_start,
pos_in_byte,

#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;
(unsigned int *) key,
(unsigned int *) decrypted);
pos_in_byte = decrypted & 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*/

if (pos_in_byte < 8) {  /* bypass the padding stuff, none sense data*/
}
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*/

if (pos_in_byte < 8) {
if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]) return 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*/```

crypt.h

```/**
* The QQ2003C protocol plugin
*
* for gaim
*
*
* 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 <csdengxm@hotmail.com>, 2005-3-27
**************************************************
*/

#ifndef Crypt_H
#define Crypt_H

#define DECRYPT 0x00
#define ENCRYPT 0x01

typedef	unsigned long int	uint32;
typedef	unsigned short		uint16;
typedef	unsigned char		uint8;

typedef	signed long int		int32;
typedef	signed short		int16;
typedef	signed char			int8;

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```