解析 TEA 加密算法(C语言、python)：

最新推荐文章于 2023-02-05 16:42:07 发布

沐一 · 林

最新推荐文章于 2023-02-05 16:42:07 发布

阅读量7.5k

点赞数 10

分类专栏：笔记文章标签： ctf

本文链接：https://blog.csdn.net/xiao__1bai/article/details/123307059

版权

笔记专栏收录该内容

27 篇文章 25 订阅

订阅专栏

解析 TEA 加密算法(C语言、python)：

TEA 加密：

XTEA 加密：

XXTEA 加密：

解析 TEA 加密算法(C语言、python)：

TEA系列概述：

TEA算法是由剑桥大学计算机实验室的 David Wheeler 和 Roger Needham于1994年发明，TEA 是Tiny Encryption Algorithm的缩写，以加密解密速度快，实现简单著称。

TEA 算法每一次可以操作 64bit(8byte)，采用 128bit(16byte) 作为 key，算法采用迭代的形式，推荐的迭代轮数是 64轮，最少 32 轮。

为解决 TEA 算法密钥表攻击的问题，TEA 算法先后经历了几次改进，从 XTEA 到 BLOCK TEA，直至最新的XXTEA。

XTEA 也称做 TEAN：

它使用与 TEA 相同的简单运算，但四个子密钥采取不正规的方式进行混合以阻止密钥表攻击。

Block TEA 算法可以对 32 位的任意整数倍长度的变量块进行加解密的操作：

该算法将 XTEA 轮循函数依次应用于块中的每个字，并且将它附加于被应用字的邻字。

XXTEA使用跟Block TEA相似的结构：

但在处理块中每个字时利用了相邻字，且用拥有两个输入量的 MX 函数代替了 XTEA 轮循函数。

上面提到的相邻字其实就是数组中相邻的项。

TEA 系列算法中均使用了一个 DELTA 常数，但 DELTA 的值对算法并无什么影响，只是为了避免不良的取值，推荐DELTA 的值取为黄金分割数 (5√-2)/2 与 232 的乘积，取整后的十六进制值为 0x9e3779B9，用于保证每一轮加密都不相同。

TEA 加密：

TEA算法介绍：

TEA 采用与 DES 算法类似的 Feistel 结构，迭代的每次循环使用加法和移位操作，对明文和密钥进行扩散和混乱，实现明文的非线性变换。TEA 密钥长度和迭代次数都是 DES 的两倍，抗“试错法”攻击的强度不低于 DES 算法。算法以32bits 的字为运算单位，而不是耗费计算能力的逐位运算。算法没有采用 DES 那样的转换矩阵，它安全、高效、占用存储空间少，非常适合在嵌入式系统中应用, 据说 QQ 就是使用 16 轮迭代的 TEA 算法。

加密过程：(解密过程逆过来即可)

#include <stdio.h>
#include <stdint.h>
 
void encrypt (uint32_t *v,uint32_t *k ){
	uint32_t v0=v[0],v1=v[1],sum=0,i;
	uint32_t delta=0x9e3779b9;
	uint32_t k0=k[0],k1=k[1],k2=k[2],k3=k[3];
	for(i=0;i<32;i++){
		sum+=delta;
		v0+=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
		v1+=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
	} 
	v[0]=v0;v[1]=v1;
}
void decrypt (uint32_t *v,uint32_t *k){
	uint32_t v0=v[0],v1=v[1],sum=0xC6EF3720,i;	//这里的sum是0x9e3779b9*32后截取32位的结果，截取很重要。
	uint32_t delta=0x9e3779b9;
	uint32_t k0=k[0],k1=k[1],k2=k[2],k3=k[3];
	for (i=0;i<32;i++){
		v1-=((v0<<4)+k2)^(v0+sum)^((v0>>5)+k3);
		v0-=((v1<<4)+k0)^(v1+sum)^((v1>>5)+k1);
		sum-=delta;
	} 
	v[0]=v0;v[1]=v1;
}

int main()
{
	uint32_t v[2]={1,2},k[4]={2,2,3,4};
	printf("加密前的数据：%u %u\n",v[0],v[1]);	//%u 以十进制形式输出无符号整数 
	encrypt(v,k);
	printf("加密后数据：%u %u\n",v[0],v[1]);
	decrypt(v,k);
	printf("解密后数据：%u %u\n",v[0],v[1]);
	return 0;
}

from ctypes import * 
def encrypt(v,k):
	v0=c_uint32(v[0])
	v1=c_uint32(v[1])
	sum1=c_uint32(0)
	delta=0x9e3779b9
	for i in range(32):
		sum1.value+=delta
		v0.value+=((v1.value<<4)+k[0])^(v1.value+sum1.value)^((v1.value>>5)+k[1])
		v1.value+=((v0.value<<4)+k[2])^(v0.value+sum1.value)^((v0.value>>5)+k[3])
	return v0.value,v1.value

def decrypt(v,k):
	v0=c_uint32(v[0])
	v1=c_uint32(v[1])
	delta=0x9e3779b9
	sum1=c_uint32(delta*32)
	for i in range(32):
		v1.value-=((v0.value<<4)+k[2])^(v0.value+sum1.value)^((v0.value>>5)+k[3])
		v0.value-=((v1.value<<4)+k[0])^(v1.value+sum1.value)^((v1.value>>5)+k[1])
		sum1.value-=delta
	return v0.value,v1.value

if __name__=='__main__':
	a=[1,2]
	k=[2,2,3,4]
	print("加密前数据:",a)
	res=encrypt(a,k)
	print("加密后的数据:",res)
	res=decrypt(res,k)
	print("解密后数据:",res)

XTEA 加密：

XTEA是TEA的升级版：

增加了更多的密钥表，移位和异或操作等等，设计者是 Roger Needham, David Wheeler。

加密过程：(解密过程逆过来即可)

#include<stdio.h>
#include<stdint.h>

void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]){
	unsigned int i;
	uint32_t v0=v[0],v1=v[1],sum=0,delta=0x9E3779B9;
	for(i=0;i<num_rounds;i++){
		v0+=(((v1<<4)^(v1>>5))+v1)^(sum+key[sum&3]);
		sum+=delta;
		v1+=(((v0<<4)^(v0>>5))+v0)^(sum+key[(sum>>11)&3]);
	}
	v[0]=v0;v[1]=v1;
}

void decipher(unsigned int num_rounds,uint32_t v[2],uint32_t const key[4]){
	unsigned int i;
	uint32_t v0=v[0],v1=v[1],delta=0x9E3779B9,sum=delta*num_rounds;
	for(i=0;i<num_rounds;i++){
	v1-=(((v0<<4)^(v0>>5))+v0)^(sum+key[(sum>>11)&3]);
	sum-=delta;
	v0-=(((v1<<4)^(v1>>5))+v1)^(sum+key[sum&3]);
	} 
	v[0]=v0;v[1]=v1;
}

int main(){
	uint32_t v[2]={1,2};
	uint32_t const k[4]={2,2,3,4};
	unsigned int r=32;				//这里是加密轮数，自己设置 
	printf("加密前原始数据：%u %u\n",v[0],v[1]);
	encipher(r,v,k);
	printf("加密后原始数据：%u %u\n",v[0],v[1]);
	decipher(r,v,k);
	printf("解密后原始数据：%u %u\n",v[0],v[1]);
	return 0;
}

from ctypes import * 
def encrypt(v,k):
	v0=c_uint32(v[0])
	v1=c_uint32(v[1])
	sum1=c_uint32(0)
	delta=0x9e3779b9
	for i in range(32):
		v0.value+=(((v1.value<<4)^(v1.value>>5))+v1.value)^(sum1.value+k[sum1.value&3])
		sum1.value+=delta
		v1.value+=(((v0.value<<4)^(v0.value>>5))+v0.value)^(sum1.value+k[(sum1.value>>11)&3])
	return v0.value,v1.value

def decrypt(v,k):
	v0=c_uint32(v[0])
	v1=c_uint32(v[1])
	delta=0x9e3779b9
	sum1=c_uint32(delta*32)
	for i in range(32):
		v1.value-=(((v0.value<<4)^(v0.value>>5))+v0.value)^(sum1.value+k[(sum1.value>>11)&3])
		sum1.value-=delta
		v0.value-=(((v1.value<<4)^(v1.value>>5))+v1.value)^(sum1.value+k[sum1.value&3])

	return v0.value,v1.value

if __name__=='__main__':
	a=[1,2]
	k=[2,2,3,4]
	print("加密前数据:",a)
	res=encrypt(a,k)
	print("加密后的数据:",res)
	res=decrypt(res,k)
	print("解密后数据:",res)

XXTEA 加密：

XXTEA算法介绍：

XXTEA，又称Corrected Block TEA，是XTEA的升级版，设计者是Roger Needham, David Wheeler。

XXTEA是一个非平衡Feistel网络分组密码，在可变长度块上运行，这些块是32位大小的任意倍数（最小64位），使用128位密钥, 是目前TEA系列中最安全的算法，但性能较上两种有所降低。

XXTEA加密过程：(解密过程逆过来即可)

#include<stdio.h>
#include<stdint.h>
#define DELTA 0x933779b9
#define MX (((z>>5^y<<2)+(y>>3^z<<4))^((sum^y)+(key[(p&3)^e]^z)))

void btea(uint32_t *v,int n,uint32_t const key[4])
{
	uint32_t y,z,sum;
	unsigned p,rounds,e;
	if(n>1)
	{
		rounds=6+52/n;	//这里可以说是预定义值，n=2是rounds=32
		sum=0;
		z=v[n-1];
		do
		{
			sum+=DELTA;
			e=(sum>>2)&3;
			for(p=0;p<n-1;p++)        //注意这里的p是从0~n-1
			{
				y=v[p+1];
				z=v[p]+=MX;
			}
			y=v[0];
			z=v[n-1]+=MX;        //这里的MX中传入的p=n-1
		}	
		while(--rounds);
	}
	else if(n<-1)
	{
		n=-n;
		rounds=6+52/n;
		sum=rounds*DELTA;
		y=v[0];
		do
		{
			e=(sum>>2)&3;
			for(p=n-1;p>0;p--)    //注意这里的p是从n-1~0,和上面是反过来的
			{
				z=v[p-1];
				y=v[p]-=MX;
			}
			z=v[n-1];
			y=v[0]-=MX;    //这里的MX中传入的 p=0
			sum-=DELTA;
		}
		while(--rounds);
	}
}

int main()
{
	uint32_t v[2]={1,2};
	uint32_t const k[4]={2,2,3,4};
	int n=2;
	printf("加密前原始数据：%u %u\n",v[0],v[1]);
	btea(v,n,k);
	printf("加密后数据：%u %u\n",v[0],v[1]);
	btea(v,-n,k);
	printf("解密后数据：%u %u\n",v[0],v[1]);
	return 0; 
	
}

from ctypes import * 

def MX(z, y, sum1, k, p, e):
    return c_uint32(((z.value>>5^y.value<<2)+(y.value>>3^z.value<<4))^((sum1.value^y.value)+(k[(p&3)^e.value]^z.value)))

def btea(v,k,n,delta):

	if n>1:
		sum1=c_uint32(0)
		z=c_uint32(v[n-1])
		rounds=6+52//n
		e=c_uint32(0)

		while rounds>0:
			sum1.value+=delta
			e.value=((sum1.value>>2)&3)	#e都要32位哦

			for p in range(n-1):
				y=c_uint32(v[p+1])
				#v[p]=c_uint32(v[p]+c_uint32((((z.value>>5^y.value<<2)+(y.value>>3^z.value<<4))^((sum1.value^y.value)+(k[(p&3)^e.value]^z.value)))).value).value
				v[p] = c_uint32(v[p] + MX(z,y,sum1,k,p,e).value).value
				z.value=v[p]

			y=c_uint32(v[0])
			#v[n-1]=c_uint32(v[n-1]+c_uint32((((z.value>>5^y.value<<2)+(y.value>>3^z.value<<4))^((sum1.value^y.value)+(k[((n-1)&3)^e.value]^z.value)))).value).value		#这里tmd传入的是k[((n-1)&3)啊我草，找了半天！！！
			v[n-1] = c_uint32(v[n-1] + MX(z,y,sum1,k,n-1,e).value).value
			z.value=v[n-1]
			rounds-=1

	else:
		sum1=c_uint32(0)
		n=-n
		rounds=6+52//n
		sum1.value=rounds*delta
		y=c_uint32(v[0])
		e=c_uint32(0)

		while rounds>0:
			e.value=((sum1.value>>2)&3)	#e都要32位哦

			for p in range(n-1, 0, -1):
				z=c_uint32(v[p-1])
				#y[p]=c_uint32(v[p]-c_uint32((((z.value>>5^y.value<<2)+(y.value>>3^z.value<<4))^((sum1.value^y.value)+(k[(p&3)^e.value]^z.value)))).value).value
				v[p] = c_uint32(v[p] - MX(z,y,sum1,k,p,e).value).value
				y.value=v[p]

			z=c_uint32(v[n-1])
			#v[n-1]=c_uint32(v[n-1]-c_uint32((((z.value>>5^y.value<<2)+(y.value>>3^z.value<<4))^((sum1.value^y.value)+(k[((n-1)&3)^e.value]^z.value)))).value).value		#这里tmd传入的是k[((n-1)&3)啊我草，找了半天！！！
			v[0] = c_uint32(v[0] - MX(z,y,sum1,k,0,e).value).value
			y.value=v[0]
			sum1.value-=delta
			rounds-=1

	return v




if __name__=='__main__':
	a=[1,2]
	k=[2,2,3,4]
	delta=0x9e3779b9
	n=2
	print("加密前数据:",a)
	res=btea(a,k,n,delta)
	print("加密后数据:",res)
	res=btea(a,k,-n,delta)
	print("解密后数据:",res)

沐一 · 林

关注

10
点赞
踩
53

收藏

觉得还不错? 一键收藏
打赏
2
评论
解析 TEA 加密算法(C语言、python)：

目录解析 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.
复制链接

扫一扫