linux 下tea加密,QQ协议的TEA加解密算法

最新推荐文章于 2024-04-09 16:32:29 发布
最新推荐文章于 2024-04-09 16:32:29 发布
阅读量528 收藏 2
点赞数
文章标签： linux 下tea加密

#include 

#include 

#include 

#include 

#include 

//#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 <> 5) + b);

z += ((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 <> 5) + d);

y -= ((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 

{

*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 

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 

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

{

if(ulPos == 8)

{

DecryptEach8Bytes(pCtx) ;

ulPos = 0 ;

}

pOut[ul] = pCtx->buf[ulPos] ;

ulPos++ ;

}

//

for(ulPadding=0; ulPadding<7; ulPadding++)

{

if(ulPos 

{

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

{

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

{

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 ;

}

724723cd19d084e40c51acb1d6b3c9b2.png

方杜若
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TEA系列加解密算法详解
Markus
07-20 9948
文章目录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轮
ios开发Tea加密解密
11-20
在iOS开发中，数据安全...Tea加密虽然简单，但在现代安全标准下可能不够强大。开发者应根据应用的具体需求，权衡性能和安全性，选择适当的加密方法。同时，要时刻关注数据完整性和保护机制，以确保用户的隐私得到保障。
易语言-QQTEA加密算法
06-25
本源码为QQTEA（第二代）的C语言代码编译提取的机器码，并为易语言用户做了一些优化。 QQTEA算法建立在标准的TEA（Tiny Encryption Algorithm）算法基础上，使用16轮的加密（这是最低限，推荐应该是32轮，应该是为了加快速度）。 TEA这个简单加密算法在中国如此有名，大概主要因为腾讯在大量协议，本地数据中使用这个算法。网上很多人甚至直接将TX的加密算法称为TEA算法。 虽然TEA算法比 DES 要简单得多， 但有很强的抗差分分析能力，加密速度也比 DES 快得多。
解析 TEA 加密算法(C语言、python)：
沐一 · 林 的博客
03-06 8307
目录 解析 TEA 加密算法(C语言、python)： TEA 加密： XTEA 加密： XXTEA 加密： 解析 TEA 加密算法(C语言、python)： TEA系列概述： TEA算法是由剑桥大学计算机实验室的 David Wheeler 和 Roger Needham于1994年发明，TEA 是Tiny Encryption Algorithm的缩写，以加密解密速度快，实现简单著称。 TEA 算法每一次可以操作 64bit(8byte)，采用 128bit(16byt.
物联网实战--驱动篇之(五)TEA和AES加密算法
最新发布
ypp240124016的博客
04-09 1339
简单介绍AES和TEA加密算法，以及如何应用，阐述物联网的安全性
TEA算法加密/解密在线工具
热门推荐
WP8HUB
12-08 1万+
TEA算法由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明。它是一种分组密码算法，其明文密文块为64比特，密钥长度为128比特。TEA算法利用不断增加的Delta(黄金分割率)值作为变化，使得每轮的加密是不同，该加密算法的迭代次数可以改变，建议的迭代次数为32轮。 工具链接：http://www.atoolbox.net/Tool.php?Id=86...
Tea加密算法
宗泽的博客
09-07 6915
简介 TEA算法由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明。它是一种分组密码算法，其明文密文块为64比特，密钥长度为128比特。TEA算法利用不断增加的Delta(黄金分割率)值作为变化，使得每轮的加密是不同，该加密算法的迭代次数可以改变，建议的迭代次数为32轮。QQ使用此加密技术，加密轮数为16轮。 加密算法实现 原理 Tea算法是一种分组加密...
TEA_example_CPP.rar_TEA算法_tea_tea c_tea 加密_tea加密
09-23
算法真的很简单，TEA算法每一次可以操作64-bit(8-byte)，采用128-bit(16-byte)作为key，算法采用迭代的形式，推荐的迭代轮数是64轮，最少32轮。目前我只知道QQ一直用的是16轮TEA。没什么好说的，先给出C语言的源代码...
QQtea.rar_QQ T_qq tea_qqtea_加密
07-15
QQ的TEA加密算法,有要的可以下下来玩玩!
golang版tea加密算法
05-30
TEA算法由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明。...TEA算法利用不断增加的Delta(黄金分割率)值作为变化，使得每轮的加密是不同，该加密算法的迭代次数可以改变，建议的迭代次数为32轮。
TEA加密算法
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
05-15 984
上述代码中，函数`tea_encrypt`和`tea_decrypt`均接受两个参数：待加密/解密的32位数据块和128位密钥。在TEA算法中，加密和解密过程都是32轮迭代加密/解密，每次迭代中都会对32位数据块进行一次加密/解密操作。加密过程中使用的delta常数为0x9e3779b9，解密过程中使用的sum常数为0xC6EF3720。TEA加密算法（Tiny Encryption Algorithm）是一种对称密钥加密算法，它的加密和解密过程都非常简单。
TEA加密解密.rar
04-05
TEA加密解密.rar
TEA算法应用
zdl158的博客
09-27 930
QQTEA 算法建立在标准 TEA算法的基础上，使用16轮的加密（这是最低限，推荐应该是32轮）。QQ在使用这个算法的时候，由于需要加密不定长的数据，所以使用了一些常规的填充办法和交织算法。 1 填充算法 如果明文本身的长度不是8的倍数，那么还要进行填充以使其成为8的倍数。以字节为单位，令N=原始字符串+10+填充字节数n，则N应该是8的倍数。 具体的填充方法：第一个字节为：(ran
【CTF-Reverse中的加密算法】RC4，TEA和Base 64加密算法
WdIg-2023的博客
06-25 2627
在我们做CTF逆向题目的时候，数据结构可谓是最基础的东西了，有很多题目都是逆向算法题目，所以好的算法能力对我们打CTF比赛还是很有帮助的，今天就来带领大家了解一下加密算法RC4，TEA和Base 64。
TEA和QQTEA
把梦想放飞在蓝色的天空里...
03-20 1970
TEA算法由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明[3]。它是一种分组密码算法，其明文密文块为64比特，密钥长度为128比特。TEA算法利用不断增加的Delta(黄金分割率)值作为变化，使得每轮的加密是不同，该加密算法的迭代次数可以改变，建议的迭代次数为32轮。 代码如下： void qq_encipher(unsigned long *c
根据腾讯公开的JS文件分析QQTEA算法
gsls200808的专栏
04-27 5964
根据网上的众多分析来看，很多QQTEA算法要么是反编译分析的，要么是根据其他版本改写的，很少有直接根据源码分析改写的，而且很多分析体现在源码里，梳理性的内容不多。后面的人去看又要重新梳理。 这里根据腾讯公开的JS文件分析，比反编译简单一些，至少能直接看到源码，JS文件：c_login_2.js 首先，看到这个JS很多人可能无从下手，首先要做的就是下载下来然后格式化 需要注意的是，网上大多数在
TEA加密算法学习
更多知识欢迎访问我的博客园：https://www.cnblogs.com/2ha0yuk7on/
03-02 5657
概述   TEA算法由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明。它是一种分组密码算法，其明文密文块为64比特，密钥长度为128比特。TEA算法利用不断增加的Delta(黄金分割率)值作为变化，使得每轮的加密是不同，该加密算法的迭代次数可以改变，建议的迭代次数为32轮。 加密过程   TEA算法使用64位的明文分组和128位的密钥，它使用Feistel分组加密框架，需要进行 64 轮迭代，尽管作者认为 32 轮已经足够了。该算法使用了一个神秘常数δ作为倍数
(加密基础)TEA篇
weixin_43632667的博客
06-04 3506
TEA算法 1.简介 TEA算法全称微型加密算法（Tiny Encryption Algorithm）是一种简单容易实现的加密算法，通常只需要很少的代码就可以实现 2.加密过程 在加密过程中，需要使用2个32位的无符号整数，密钥为128位，四个32位无符号整数 流程图： 加密中一共有五个量参与运算，l(第一个明文)，r(第二个明文)，sum=0，delta给定一个定值，密钥key每一轮： sum+=delta; l += ((r << 4) + key[0]) ^ (r + sum) ^ ((
tea加密解密不一样
10-15
Tea加密和解密过程中使用的算法是不同的。Tea加密算法，也称为Tiny Encryption Algorithm，是一种对称密钥加密算法。其加密过程是将明文分为多个块，然后对每个块进行一系列的加密操作，包括轮数、加密轮函数、秘钥的生成等，最终生成密文。而解密过程则是将密文经过相应的解密操作，还原为原始的明文。 Tea加密算法的特点是运算简单、加密速度快，尤其适用于嵌入式设备等资源受限的环境。它的安全性主要依靠于其算法的设计特点和密钥的保密性。 在Tea加密的过程中，明文和密文的长度是相同的，但是解密过程中使用到的算法与加密过程不同。解密需要使用与加密过程相反的操作，通过对密文进行逆操作，还原为明文。这种非对称性使得只有持有正确密钥的人才能够正确解密密文，增强了加密的安全性。 总结来说，Tea加密和解密过程中使用的算法不同，加密过程将明文转化为密文，解密过程则将密文还原为明文。这种不同的运算方式使得只有正确的密钥才能够正确解密，保证了数据的安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值