QQ协议的TEA加解密算法

最新推荐文章于 2024-06-27 14:43:55 发布
最新推荐文章于 2024-06-27 14:43:55 发布
阅读量432 收藏 2
点赞数
原文链接：https://my.oschina.net/osbin/blog/195358
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <time.h>

//#define CRYPT_ONE_BYTE

typedef char int8 ;
typedef unsigned char uint8 ;
typedef short int16 ;
typedef unsigned short uint16 ;
typedef long int32 ;
typedef unsigned long uint32 ;

typedef struct tagTEACTX
{
	uint8 buf[8] ;
	uint8 bufPre[8] ;
	const uint8 *pKey ; //指向16字节的key 
	uint8 *pCrypt ;
	uint8 *pCryptPre ;
} TEACTX, *LPTEACTX ;

uint16 Host2NetShort(uint16 usHost)
{
	const uint16 us = 0x1234 ;
	return ((uint8 *)&us)[0] == 0x12 ? usHost : ((usHost>>8) | (usHost<<8)) ;
}

uint16 Net2HostShort(uint16 usNet)
{
	return Host2NetShort(usNet) ;
}

uint32 Host2NetLong(uint32 ulHost)
{
	const uint16 us = 0x1234 ;
	return ((uint8 *)&us)[0] == 0x12 ? ulHost : (((ulHost>>8) & 0xFF00) | 
		((ulHost<<8) & 0xFF0000) | (ulHost<<24) | (ulHost>>24)) ;
}

uint32 Net2HostLong(uint32 ulHost)
{
	return Host2NetLong(ulHost) ;
}

//TEA加密。v明文8字节。k密钥16字节。w密文输出8字节。 
void EnCipher(const uint32 *const v, const uint32 *const k, uint32 *const w)
{
	register uint32 
		y     = Host2NetLong(v[0]),
		z     = Host2NetLong(v[1]),
		a     = Host2NetLong(k[0]),
		b     = Host2NetLong(k[1]),
		c     = Host2NetLong(k[2]),
		d     = Host2NetLong(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] = Net2HostLong(y);
	w[1] = Net2HostLong(z);
}

//TEA解密。v密文8字节。k密钥16字节。w明文输出8字节。 
void DeCipher(const uint32 *const v, const uint32 *const k, uint32 *const w)
{
	register uint32
		y     = Host2NetLong(v[0]),
		z     = Host2NetLong(v[1]),
		a     = Host2NetLong(k[0]),
		b     = Host2NetLong(k[1]),
		c     = Host2NetLong(k[2]),
		d     = Host2NetLong(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] = Net2HostLong(y);
	w[1] = Net2HostLong(z);
}

uint32 Random(void)
{
	return (uint32)rand();
	//return 0xdead ;
}

//每次8字节加密 
static void EncryptEach8Bytes(TEACTX *pCtx)
{
#ifdef CRYPT_ONE_BYTE
	uint32 i ;
	uint8 *pPlain8, *pPlainPre8, *pCrypt8, *pCryptPre8 ;
	pPlain8 = (uint8 *)pCtx->buf ;
	pPlainPre8 = (uint8 *)pCtx->bufPre ;
	pCrypt8 = (uint8 *)pCtx->pCrypt ;
	pCryptPre8 = (uint8 *)pCtx->pCryptPre ;
	//本轮明文与上一轮的密文异或 
	for(i=0; i<8; i++)
		pPlain8[i] ^= pCryptPre8[i] ;
	//再对异或后的明文加密 
	EnCipher((uint32 *)pPlain8, (uint32 *)pCtx->pKey, (uint32 *)pCrypt8) ;
	//将加密后的密文与上一轮的明文(其实是上一轮明文与上上轮密文异或结果)异或
	for(i=0; i<8; i++)
		pCrypt8[i] ^= pPlainPre8[i] ;
	//
	for(i=0; i<8; i++)
		pPlainPre8[i] = pPlain8[i] ;
#else
	uint32 *pPlain8, *pPlainPre8, *pCrypt8, *pCryptPre8 ;
	pPlain8 = (uint32 *)pCtx->buf ;
	pPlainPre8 = (uint32 *)pCtx->bufPre ;
	pCrypt8 = (uint32 *)pCtx->pCrypt ;
	pCryptPre8 = (uint32 *)pCtx->pCryptPre ;
	pPlain8[0] ^= pCryptPre8[0] ;
	pPlain8[1] ^= pCryptPre8[1] ;
	EnCipher(pPlain8, (const uint32 *)pCtx->pKey, pCrypt8) ;
	pCrypt8[0] ^= pPlainPre8[0] ;
	pCrypt8[1] ^= pPlainPre8[1] ;
	pPlainPre8[0] = pPlain8[0] ;
	pPlainPre8[1] = pPlain8[1] ;
#endif
	pCtx->pCryptPre = pCtx->pCrypt ;
	pCtx->pCrypt += 8 ;
}

//加密。pPlain指向待加密的明文。ulPlainLen明文长度。pKey密钥16字节。
//pOut指向密文输出缓冲区。pOutLen输入输出参数，指示输出缓冲区长度、密文长度。 
uint32 Encrypt(TEACTX *pCtx, const uint8 *pPlain, uint32 ulPlainLen, 
	const uint8 *pKey, uint8 *pOut, uint32 *pOutLen)
{
	uint32 ulPos, ulPadding, ulOut ;
	const uint8 *p ;
	if(pPlain == NULL || ulPlainLen == 0 || pOutLen == NULL)
		return 0 ;
	//计算需要填充的字节数
	//整个加密流程下来，不管明文长度多少，填充10个字节是固定的，
	//然后再根据明文的长度计算还需要填充的字节数。 
	ulPos = (8 - ((ulPlainLen + 10) & 0x07)) & 0x07 ;
	//计算加密后的长度
	ulOut = 1 + ulPos + 2 + ulPlainLen + 7 ;
	if(*pOutLen < ulOut)
	{
		*pOutLen = ulOut ;
		return 0 ;
	}
	*pOutLen = ulOut ;
	memset(pCtx, 0, sizeof(TEACTX)) ;
	pCtx->pCrypt = pOut ;
	pCtx->pCryptPre = pCtx->bufPre ;
	pCtx->pKey = pKey ;
	//buf[0]的最低3bit位等于所填充的长度
	pCtx->buf[0] = (uint8)((Random() & 0xF8) | ulPos) ;
	//用随机数填充上面计算得到的填充长度(每个字节填充的内容是一样的)。
	//这里填充的起始位置是&buf[1]。
	memset(pCtx->buf+1, (uint8)Random(), ulPos++) ;
	//至少再填充两字节
	for(ulPadding=0; ulPadding<2; ulPadding++)
	{
		if(ulPos == 8)
		{
			EncryptEach8Bytes(pCtx) ;
			ulPos = 0 ;
		}
		pCtx->buf[ulPos++] = (uint8)Random() ;
	}
	p = pPlain ;
	while(ulPlainLen > 0)
	{
		if(ulPos == 8)
		{
			EncryptEach8Bytes(pCtx) ;
			ulPos = 0 ;
		}
		pCtx->buf[ulPos++] = *(p++) ;
		ulPlainLen-- ;
	}
	//末尾再添加7字节0后加密，在解密过程的时候可以用来判断key是否正确。 
	for(ulPadding=0; ulPadding<7; ulPadding++)
		pCtx->buf[ulPos++] = 0x00 ;
	//
	EncryptEach8Bytes(pCtx) ;
	return ulOut ;
}

//每次8字节进行解密 
static void DecryptEach8Bytes(TEACTX *pCtx)
{
#ifdef CRYPT_ONE_BYTE
	uint32 i ;
	uint8 bufTemp[8] ;
	uint8 *pBuf8, *pBufPre8, *pCrypt8, *pCryptPre8 ;
	pBuf8 = (uint8 *)pCtx->buf ;
	pBufPre8 = (uint8 *)pCtx->bufPre ;
	pCrypt8 = (uint8 *)pCtx->pCrypt ;
	pCryptPre8 = (uint8 *)pCtx->pCryptPre ;
	//当前的密文与前一轮明文(实际是前一轮明文与前前轮密文异或结果)异或 
	for(i=0; i<8; i++)
		bufTemp[i] = pCrypt8[i] ^ pBufPre8[i] ;
	//异或后的结果再解密(解密后得到当前名文与前一轮密文异或的结果，并非真正明文)
	DeCipher((uint32 *)bufTemp, (uint32 *)pCtx->pKey, (uint32 *)pBufPre8) ;
	//解密后的结果与前一轮的密文异或，得到真正的明文 
	for(i=0; i<8; i++)
		pBuf8[i] = pBufPre8[i] ^ pCryptPre8[i] ;
#else
	uint32 bufTemp[2] ;
	uint32 *pBuf8, *pBufPre8, *pCrypt8, *pCryptPre8 ;
	pBuf8 = (uint32 *)pCtx->buf ;
	pBufPre8 = (uint32 *)pCtx->bufPre ;
	pCrypt8 = (uint32 *)pCtx->pCrypt ;
	pCryptPre8 = (uint32 *)pCtx->pCryptPre ;
	bufTemp[0] = pCrypt8[0] ^ pBufPre8[0] ;
	bufTemp[1] = pCrypt8[1] ^ pBufPre8[1] ;
	DeCipher(bufTemp, (const uint32 *)pCtx->pKey, pBufPre8) ;
	pBuf8[0] = pBufPre8[0] ^ pCryptPre8[0] ;
	pBuf8[1] = pBufPre8[1] ^ pCryptPre8[1] ;
#endif
	pCtx->pCryptPre = pCtx->pCrypt ;
	pCtx->pCrypt += 8 ;
}

//解密。pCipher指向待解密密文。ulCipherLen密文长度。pKey密钥16字节。
//pOut指向明文输出缓冲区。pOutLen输入输出参数，指示输出缓冲区长度、明文长度。 
uint32 Decrypt(TEACTX *pCtx, const uint8 *pCipher, uint32 ulCipherLen, 
	const uint8 *pKey, uint8 *pOut, uint32 *pOutLen)
{
	uint32 ulPos, ulPadding, ulOut, ul ;
	// 待解密的数据长度最少16字节，并且长度满足是8的整数倍。
	if(pCipher == NULL || pOutLen == NULL || 
			ulCipherLen < 16 || (ulCipherLen & 0x07) != 0)
		return 0 ;
	pCtx->pKey = pKey ; //***2016-06-15 这个忘记加了，补上***
	// 先解密头8字节，以便获取第一轮加密时填充的长度。
	DeCipher((const uint32 *)pCipher, (const uint32 *)pKey, (uint32 *)pCtx->bufPre) ;
	for(ul=0; ul<8; ul++)
		pCtx->buf[ul] = pCtx->bufPre[ul] ;
	ulPos = pCtx->buf[0] & 0x07 ; //第一轮加密时填充的长度
	if(ulPos > 1)
	{
		for(ulOut=2; ulOut<=ulPos; ulOut++)
		{
			if(pCtx->buf[1] != pCtx->buf[ulOut])
			{
				*pOutLen = 0 ;
				return 0 ; //解密失败 
			}
		}
	}
	ulOut = ulCipherLen - ulPos - 10 ;
	if(ulPos + 10 > ulCipherLen || *pOutLen < ulOut)
		return 0 ;
	pCtx->pCryptPre = (uint8 *)pCipher ;
	pCtx->pCrypt = (uint8 *)pCipher + 8 ;
	ulPos++ ;
	for(ulPadding=0; ulPadding<2; ulPadding++)
	{
		if(ulPos == 8)
		{
			DecryptEach8Bytes(pCtx) ;
			ulPos = 0 ;
		}
		ulPos++ ;
	}
	//
	for(ul=0; ul<ulOut; ul++)
	{
		if(ulPos == 8)
		{
			DecryptEach8Bytes(pCtx) ;
			ulPos = 0 ;
		}
		pOut[ul] = pCtx->buf[ulPos] ;
		ulPos++ ;
	}
	//
	for(ulPadding=0; ulPadding<7; ulPadding++)
	{
		if(ulPos < 8)
		{
			if(pCtx->buf[ulPos] != 0x00)
			{
				*pOutLen = 0 ;
				return 0 ;
			}
		}
		ulPos++ ;
	}
	*pOutLen = ulOut ;
	return 1 ;
}

void PrintBuffer(const uint8 *buf, uint32 ulLen)
{
	uint32 i ;
	for(i=0; i<ulLen; i++)
	{
		printf("%.2X ", buf[i]) ;
		if((i+1) % 16 == 0)
			putchar('\n') ;
	}
	if((ulLen & 0x0F) != 0)
		putchar('\n') ;
}

int main(void)
{
	const char *pPK[][2] = 
	{
		//明文--密钥 
		{"tea",	"123456789abcdef"},
		{"tea",	"123456789abcdef"},
		{"123456",	"password1234567"},
		{"AABBCCD",	"aabbccddeeffggh"},
		{"Hello World 你好世界！",	"aabbccddeeffggh"}
	} ;
	TEACTX ctx ;
	uint8 bufEnc[512], bufDec[512] ;
	uint32 ulEnc, ulDec, ulRet ;
	int i ;
	for(i=0; i<sizeof(pPK)/sizeof(pPK[0]); i++)
	{
		printf("明文：%s\n密钥：%s\n", pPK[i][0], pPK[i][1]) ;
		ulEnc = sizeof(bufEnc) ;
		Encrypt(&ctx, (const uint8 *)pPK[i][0], strlen(pPK[i][0])+1, 
				(const uint8 *)pPK[i][1], (uint8 *)bufEnc, &ulEnc) ;
		printf("密文：\n") ;
		PrintBuffer(bufEnc, ulEnc) ;
		ulDec = sizeof(bufDec) ;
		ulRet = Decrypt(&ctx, bufEnc, ulEnc, (const uint8 *)pPK[i][1], 
				(uint8 *)bufDec, &ulDec) ;
		if(ulRet != 0)
			printf("解密后明文：%s\n", bufDec) ;
		else
			printf("解密失败！\n") ;
		putchar('\n') ;
	}
	return 0 ;
}

170604_1R8A_82631.png

转载于:https://my.oschina.net/osbin/blog/195358

weixin_34347651
关注
c# tea算法_C#中QQ协议TEA加密解密代码
weixin_39939665的博客
12-19 564
网上找到的qq协议的TEA加密和解密说明如下： 也有很多源代码，但是感觉上代码比较复杂，不容易看。我用C#重写了下。* QQ消息的加密算法是一个16次的迭代过程，并且是反馈的，每一个加密单元是8字节，输出也是8字节，密钥是16字节* 我们以prePlain表示前一个明文块，plain表示当前明文块，crypt表示当前明文块加密得到的密文块，preCrypt表示前一个密文块* f表示加密算法，d表示...
QQ TEA加密算法 JAVA实现
xueba8的博客
02-07 2259
TeaUtil.java： import java.io.ByteArrayOutputStream; import java.util.Random; /** * 加密解密QQ消息的工具类. QQ消息的加密算法是一个16次的迭代过程，并且是反馈的，每一个加密单元是8字节，输出也是8字节，密钥是16字节 * 我们以prePlain表示前一个明文块，plain表示当前明文块，crypt表...
QQ-TEA加解密代码
03-21
QQ-TEA加解密工具代码，分析QQ报文特征和协议，解密本地QQ聊天
QQTEA加密解密实现
把梦想放飞在蓝色的天空里...
11-14 4772
本文从konglinglong的项目wingIM转载而来，使用者必须尊重原作者的著作权，在其授权范围内使用。中文注释为我所加，感谢原作者的辛勤劳动和无私共享精神！ wingIM发布在谷歌代码里，地址为：http://code.google.com/p/wingim/ crypt.h /** * The QQ2003C protocol plugin * * for gaim
Const 修饰* 详解
最新发布
weixin_45511753的博客
06-27 457
/Const 修饰指针变量，所以uP_1的地址是只读(Flash)//Const 修饰*，所以uP_2可以修改，uP_2里的内容只读。
易语言-QQTEA加密算法
06-25
本源码为QQTEA（第二代）的C语言代码编译提取的机器码，并为易语言用户做了一些优化。 QQTEA算法建立在标准的TEA（Tiny Encryption Algorithm）算法基础上，使用16轮的加密（这是最低限，推荐应该是32轮，应该是为了加快速度）。 TEA这个简单加密算法在中国如此有名，大概主要因为腾讯在大量协议，本地数据中使用这个算法。网上很多人甚至直接将TX的加密算法称为TEA算法。 虽然TEA算法比 DES 要简单得多， 但有很强的抗差分分析能力，加密速度也比 DES 快得多。
QQ加密算法浅谈(TEA加解密算法)
Didiの私人会所
03-28 8423
Tencent QQ的加密算法就采用了TEA算法 TEA(Tiny Encryption Algorithm) 是一种优秀的数据加密算法，虽然它比 DES(Data Encryption Standard) 要简单得多， 但有很强的抗差分分析能力，加密速度也比 DES 快得多，而且对 64 位数据加密的密钥长达 128 位，安全性相当好。 Pascal(Delphi)代码如下:nt
QQTEA算法源码.rar
04-05
QQTEA算法源码.rar
TEA系列加解密算法详解
热门推荐
Markus
07-20 1万+
文章目录TEA系列概述TEA算法介绍TEA加密过程C语言实现：XTEA算法介绍XTEA加密过程C语言实现XTEA算法介绍XXTEA加密过程C语言实现参考 TEA系列概述 TEA算法是由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明，TEA是Tiny Encryption Algorithm的缩写，以加密解密速度快，实现简单著称。TEA算法每一次可以操作64bit(8byte)，采用128bit(16byte)作为key，算法采用迭代的形式，推荐的迭代轮数是64轮
易语言TEA加密解密源码.7z
05-18
在给定的“易语言TEA加密解密源码.7z”压缩包中，包含的是关于TEA（Tiny Encryption Algorithm）加密算法的源代码，这种算法是用于数据加密的一种快速、简洁的方法。 TEA加密算法是由David Wheeler和Roger Needham...
数据的加密传输——单片机上实现TEA加密解密算法.pdf
04-01
虽然现在有些系统可能使用更少的轮数，例如QQ使用的16轮TEA，但减少轮数可能会影响算法的安全性。 在单片机环境下，如16位的msp430，即使晶振频率仅为6MHz，TEA算法也能实现每秒两三百次的加密和解密操作。这表明...
qqTEA算法之php实现（仅供学习）
09-06
这是一个用php实现QQ of TEA算法的例子！
TEA加密算法
07-16
TEA加密算法的加强版XTEA的实现，包含EBC-TEA和CBC-TEA两个模式的不同加密方式。可用于测试分组加密的ECB和CBC的优劣性。
TEA加密解密.rar
04-05
TEA加密解密.rar
QQ协议TEA加密解密代码 C#
weixin_30432579的博客
11-08 430
网上找到的qq协议的TEA加密和解密说明如下： 也有很多源代码，但是感觉上代码比较复杂，不容易看。我用C#重写了下。 基于2008协议 * QQ消息的加密算法是一个16次的迭代过程，并且是反馈的，每一个加密单元是8字节，输出也是8字节，密钥是16字节 * 我们以prePlain表示前一个明文块，plain表示当前明文块，crypt表示当前明文块加密得到的密文块，preCr...
【转】QQ Tea加密解密单元 Delphi
okmnji79513的专栏
10-12 2462
http://www.cnblogs.com/ryyd/archive/2008/10/14/1311085.html    ///----------------------------------------------------------/  //|               QQ TEA加密解密单元 Delphi版                       |//|  
QQ Tea加密解密单元 Delphi
weixin_30558305的博客
10-14 171
DELPHI 决定还是不搞了，实在没VS好弄 把以前写的一些东西都翻出来，留个纪念吧 QQTea 加密解密单元，做QQ聊天记录解密时转自LUMAQQ结合VB版重写的 代码查看 ///----------------------------------------------------------\ //|QQTEA加密解密单元Delphi版...
TEA算法应用
zdl158的博客
09-27 938
QQTEA 算法建立在标准 TEA算法的基础上，使用16轮的加密（这是最低限，推荐应该是32轮）。QQ在使用这个算法的时候，由于需要加密不定长的数据，所以使用了一些常规的填充办法和交织算法。 1 填充算法 如果明文本身的长度不是8的倍数，那么还要进行填充以使其成为8的倍数。以字节为单位，令N=原始字符串+10+填充字节数n，则N应该是8的倍数。 具体的填充方法：第一个字节为：(ran
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值