TEA加密算法

在密码学中，微型加密算法（Tiny Encryption Algorithm，TEA）是一种易于描述和执行的块密码，通常只需要很少的代码就可实现。 其设计者是剑桥大学计算机实验室的大卫·惠勒与罗杰·尼达姆。

特征

  • 明文：两个32位无符号整数

  • 密钥：4个32位无符号整数，即密钥长度为128位

  • delta常数：一般为0x9e3779b9，取的是

  • 不影响加密算法的安全性，但是可以避免一些错误。
  • 置换操作

加密过程

TEA_InfoBox_Diagram

可以看出：是把输入分成两组，分别是v[0],v[1]，绿色方格为做加法，红色圆圈为做异或，可以看出，用密钥k[0],k[1]加密后，把两个数做一次置换，再加密一次，这样经过多轮加密以后就可以通过简单的算法把两个数变得很复杂，满足加密算法混乱和扩散的特性。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#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;//delta常数                    
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];//密钥 
    for (i=0; i < 32; i++) {//进行32轮加密                       
        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=delta*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};  
    // v为要加密的数据是两个32位无符号整数  
    // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位  
    printf("加密前原始数据：%u %u\n",v[0],v[1]);  
    encrypt(v, k);  
    printf("加密后的数据：%u %u\n",v[0],v[1]);  
    decrypt(v, k);  
    printf("解密后的数据：%u %u\n",v[0],v[1]);  
    return 0;  
}

出题方式

  • 直接给出加密算法代码然后写解密脚本
  • 改变加密轮数或者delta的值，或者对delta进行操作，通过拆分或者异或等藏起来

XTEA加密算法

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

特征

  • 双整形加密，4个32位密钥，delta常数，异或运算，置换操作，和TEA类似

  • 对密钥的访问和使用方法和TEA不同

加密过程

查看源图像

也是分成两组，但是把密钥和sum值关联起来，使得对v[0]和v[1]加密的时候每一轮所用的密钥也不一样，增强了加密算法的安全性。其中sum[i-1]为本轮加密未加delta时的sum值，sum[i]为加上delta的sum值。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#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;//num_rounds建议取值为32  
    // v为要加密的数据是两个32位无符号整数  
    // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位  
    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;  
}

XXTEA加密算法

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

特征

  • 4个32位密钥，delta常数，异或运算

  • 更为复杂的代码,大雾,但是还是有规律可循的

加密过程

XXTEA
下面重点解读代码逻辑(updated on 1.13)

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <stdio.h>
#include <stdint.h>
#define DELTA 0x9e3779b9
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
//一个混淆操作，根据密码学的扩散原理，让算法更安全，同时也是xxtea的特征之一 
void xxtea(uint32_t *v, int n, uint32_t const key[4]){
    uint32_t y, z, sum;
    unsigned p, rounds, e;
    //n是明文长度，sum对应图中的D，p对应图中的密钥下标索引，e是图中的D>>2

    /* Coding Part */
    if (n > 1) {
        rounds = 6 + 52/n;//循环轮数
        sum = 0;
        z = v[n-1];
        do{
            sum += DELTA;
            e = (sum >> 2) & 3;
            for (p=0; p<n-1; p++){
                y = v[p+1];
                z = v[p] += MX;//本质上还是双整形加密,用v[p]和v[p+1]对v[p]加密
                /*
                v[p] += MX;
                z = v[p];
                */
            }
            y = v[0];
            z = v[n-1] += MX;//一轮加密的最后用v[n-1]和v[0]对v[n-1]加密
        }
        while (--rounds);
    }
    else if (n < -1)/* Decoding Part */{
        n = -n;
        rounds = 6 + 52/n;
        sum = rounds*DELTA;
        y = v[0];
        do{
            e = (sum >> 2) & 3;
            for (p=n-1; p>0; p--){
                z = v[p-1];
                y = v[p] -= MX;
            }
            z = v[n-1];
            y = v[0] -= MX;
            sum -= DELTA;
        }
        while (--rounds);
    }
}
 
int main()
{
    uint32_t v[2]= {1,2};
    uint32_t const k[4]= {2,2,3,4};
    int n= 2; //n的绝对值表示v的长度，取正表示加密，取负表示解密
    // v为要加密的数据是两个32位无符号整数
    // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位
    printf("%#10x %#10x\n",v[0],v[1]);
    xxtea(v, n, k);//n>0为加密
    printf("%#10x %#10x\n",v[0],v[1]);
    xxtea(v, -n, k);//n<0为解密
    printf("%#10x %#10x\n",v[0],v[1]);
    return 0;
}

python调用现成模块

通过pip install xxtea-py安装后可以调用

1
2
3
4
5
6
import xxtea
text = "Hello World!"
key = "1234567890"
encrypt_data = xxtea.encrypt(text, key)
decrypt_data = xxtea.decrypt_utf8(encrypt_data, key)
print(text == decrypt_data);

参考资料：

TEA，XTEA，XXTEA加密算法概要 | Tardis’s blog (taardisaa.github.io)

TEA、XTEA、XXTEA加密解密算法 - 简书 (jianshu.com)