首页 分享

# TEA 系列

# TEA 加密解密

介绍
在密码学中，微型加密算法（Tiny Encryption Algorithm，TEA）是一种易于描述和执行的块密码，通常只需要很少的代码就可实现。
代码的特点：

加密使用的数据为2个32位无符号整数，密钥为4个32位无符号整数即密钥长度为128位（当加密解密的对象是一串数组的时候，需要将这个32位无符号整数的数组每两个32位无符号整数划分为一组，对每一组数据单独加密解密得到结果）；
该算法使用了一个常数 δ 作为倍数，它来源于黄金比率，以保证每一轮加密都不相同。但 δ 的精确值似乎并不重要，这里 TEA 把它定义为 δ=「(√5 - 1)231」（也就是程序中的 0×9E3779B9）作为魔数

加密过程
12

TEA 加密算法的实现
参数要求：输入一定要是一个 64bit 的数字，或者可以写作一个拥有两个元素的 32bit 的数组。并且需要一个两倍长度的 key（int [4]), 即一个 128 位的数字（拥有四个元素的 32bit 的数组）

加密特征：存在一个 delta 值，这个值会不停的增加到 sum 之中，形成一种循环的效果；会有一个位移 -> 与密钥相加 -> 异或的过程；计算 delta 的 sum 状态值也会参与

1
2
3
4
5
6
7
8
9
10
11
void encrypt (uint32_t v[2], const uint32_t k[4]) {
    uint32_t v0=v[0], v1=v[1], sum=0, i;           /* set up */
    uint32_t delta=0x9E3779B9;                     /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */
    for (i=0; i<32; i++) {                         /* basic cycle start */
        sum += delta;
        v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
    }                                              /* end cycle */
    v[0]=v0; v[1]=v1;
}

TEA 解密算法的实现
参数要求：输入一定要是一个 64bit 的数字，或者可以写作一个拥有两个元素的 32bit 的数组。并且需要一个两倍长度的 key（int [4]), 即一个 128 位的数字（拥有四个元素的 32bit 的数组）

1
2
3
4
5
6
7
8
9
10
11
12
13
//解密函数  
void decrypt (uint32_t* v, uint32_t* k) {  
    uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i;  /* set up */  
    uint32_t delta=0x9e3779b9;                     /* a key schedule constant */  
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];   /* cache key */  
    sum = delta << 5;   //32轮运算，所以是2的5次方；16轮运算，所以是2的4次方；8轮运算，所以是2的3次方
    for (i=0; i<32; i++) {                         /* basic cycle start */  
        v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);  
        v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);  
        sum -= delta;  
    }                                              /* end cycle */  
    v[0]=v0; v[1]=v1;  
}

# XTEA 加密解密

介绍
XTEA 是 TEA 的升级版，增加了更多的密钥表，移位和异或操作

加密过程
13

XTEA 加密算法的实现
相较于 TEA 的变化：
由之前的 **((v1<<4) + k0) ^ ((v1>>5) + k1)** 变化成了 ((v1 << 4) ^ (v1 >> 5)) + v1)，此时 v1 内部数据的加密变化不再受到密钥的影响。

原先的 v1 + sum 变成了 (sum + key [sum & 3]) 以及 sum + key [(sum>>11) & 3]，密钥变成了轮转使用，而不是固定只针对某种数据进行加密（解密）。并且此时密钥的选取受到 sum 的影响

sum += delta 的时机由每次加密开头就发生变化到 v0，v1 两个 block 加密的中间。

输入的参数：输入一定要是一个 64bit 的数字，或者可以写作一个拥有两个元素的 32bit 的数组。并且需要一个两倍长度的 key（int [4]), 即一个 128 位的数字（拥有四个元素的 32bit 的数组），注意这里循环的次数不是固定的了，是需要传入的参数 num_rounds

1
2
3
4
5
6
7
8
9
10
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;  
}

XTEA 解密算法的实现
输入的参数：输入一定要是一个 64bit 的数字，或者可以写作一个拥有两个元素的 32bit 的数组。并且需要一个两倍长度的 key（int [4]), 即一个 128 位的数字（拥有四个元素的 32bit 的数组），注意这里循环的次数不是固定的了，是需要传入的参数 num_rounds

1
2
3
4
5
6
7
8
9
10
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;  
}

# XXTEA 加密解密

介绍
XTEA 再度进化， 变成了支持块加密 XXTEA

加密过程
14

XXTEA 加密解密算法的实现
特点：在可变长度块上运行，这些块是 32 位大小的任意倍数（最小 64 位），使用 128 位密钥，是目前 TEA 系列中最安全的算法，但性能较上两种有所降低。

参数：输入的是至少拥有两个元素的 32bit 的数组，密钥的长度仍然是 128 位，即拥有 4 个元素 32 位长度的数组

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
#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)))  
  
void btea(uint32_t *v, int n, uint32_t const key[4])  
{  
    uint32_t y, z, sum;  
    unsigned p, rounds, e;  
    if (n > 1)            /* Coding Part */  
    {  
        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;  
            }  
            y = v[0];  
            z = v[n-1] += MX;  
        }  
        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);  
    }  
}

# 逆向中 TEA 系列加密的识别

解决逆向题大部分出现 TEA 的场合都是（识别算法 -> 编写对应解密程序）
分析二进制文件中的算法的时候有几个识别的特征：

可能存在针对64bit以及128bit数字的操作（输入的msg和key） ，一般会用无符号的32位的数组表示；   

存在先进行位移，然后异或的类似操作（(z>>5^y<<2) 这类混合变换）**(z>>5^y<<2)就是xxtea加密了，存在(v0 << 4)** 和 **(v0 >> 5)**移位就是tea和xtea加密了；  

前面一个复杂的混合变换的结果可能会叠加到另一个值上，两者相互叠加（Feistel 结构）

获取密钥的时候，会使用某一个常量值作为下标（key[(sum>>11) & 3]）存在轮换的方式获得密钥 就是xtea或者xxtea了；

会在算法开始定义一个delta，并且这个值不断的参与算法，但是从来不会受到输入的影响（delta数值如果没有魔改就是0x9e3779b9）如果出现了0x9e3779b9这个数字一般就能确定是TEA加密系列

​
​
参考文章：


​

更新于 阅读次数 次