TEA | LinXxx

TEA加密

特征：0x9e379b9,循环32轮，左移4，右移5
每次加密8个字节(拆分)
魔改方式：
1.改变delta的值
2.每轮加密时添加可逆运算
3.迭代赋值回去后，添加可逆运算
加密：

void encrypt(uint32_t* v,uint32_t* key){
uint32_t v0=v[0],v1=v[1],sum=0,i;
uint32_t delta=0x9e3779b9;
uint32_t k0=key[0],k1=key[1],k2=key[2],k3=key[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;
}

解密:

/ c#

void decrypt(uint32_t* v,uint32_t* key){
uint32_t v0=v[0],v1=v[1],sum=0xC6EF3720,i;
uint32_t delta=0x9e3779b9;
uint32_t k0=key[0],k1=key[1],k2=key[2],k3=key[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;
}

解密脚本：

/ c#

c
//tea
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
void Decrypt(uint32_t* data, uint32_t* key)
{
    uint32_t v0 = data[0], v1 = data[1];
    uint32_t delta = 0x9e3779b9;
    uint32_t sum = delta * 32;

    for (int i = 0; i < 32; i++)
    {
        v1 -= ((v0 << 4) + key[2]) ^ (v0 + sum) ^ ((v0 >> 5) + key[3]);
        v0 -= ((v1 << 4) + key[0]) ^ (v1 + sum) ^ ((v1 >> 5) + key[1]);
        sum -= delta;
    }

    data[0] = v0;
    data[1] = v1;
}

int main()
{
    uint32_t encryptedData[] = { 0xc873914f, 0x4a628600, 0x20c77a1c, 0x1a877aaa, 0xd6faa982, 0x60d1c964, 0xb9884c32, 0x2a08a862, 0xc74a0036, 0x8f2ee196, 0xef08a6a9, 0xa3850896 };
    uint32_t key[] = { 0x11111111, 0x11111111, 0x11111111, 0x11111111 };

    int dataSize = sizeof(encryptedData) / sizeof(encryptedData[0]);
    for (int i = 0; i < dataSize; i += 2)
    {
        Decrypt(&encryptedData[i], key);
    }
    int decryptedSize = dataSize * 4 + 1;
    char* decryptedString = (char*)malloc(decryptedSize);
    memset(decryptedString, 0, decryptedSize);
    for (int i = 0; i < dataSize; i++)
    {
        char* bytes = (char*)&encryptedData[i];
        decryptedString[i * 4] = bytes[0];
        decryptedString[i * 4 + 1] = bytes[1];
        decryptedString[i * 4 + 2] = bytes[2];
        decryptedString[i * 4 + 3] = bytes[3];
    }
    printf("Decrypted String: %s\n", decryptedString);
    free(decryptedString);
    return 0;
}

xtea

加解密代码：

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

/* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */
//加密
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 & 3)保证索引取0，1，2，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

改变了循环的轮数和主要加密方式
相比TEA,xTEA算法，xxTEA算法的优势是原字符串长度可以不是4的倍数了
加密：

/ c#

#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)))     //MX函数替代了tea和xtea的轮循函数
void btea(uint32_t *v,int n,uint32_t const key[4])//n为v数组长度 (原代码有多少四个字节长度的元素)
{
    uint32_t y,z,sum;
    unsigned p,rounds,e;
    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];
                v[p]+=MX;
                z=v[p];
            }
            y=v[0];
            z=v[n-1]+=MX;
        }
        while(--rounds); 
    }
}

/ c#

#include <stdint.h>
/* XXTEA加密算法的加密过程 */
void xxtea_encrypt(uint32_t *v, int n, uint32_t *key) {
    uint32_t y, z, sum, delta, e;
    uint32_t p, q, rounds, limit;
    uint32_t *k = key;
    rounds = 6 + 52 / n;        // 计算加密轮数
    sum = 0;
    delta = 0x9E3779B9;         // 初始化delta常数
    limit = rounds * delta;     // 计算sum的最大值
    q = 6 + limit / delta;
    while (q-- > 0) {           // 执行加密轮数
        sum += delta;           // 更新sum
        e = sum >> 2 & 3;       // 计算e值
        for (p = 0; p < n; p++) {   // 对每个数据块执行加密操作
            y = v[(p + 1) % n];
            z = v[p] += ((v[(p + n - 1) % n] >> 5) ^ (y << 2)) + ((y >> 3) ^ (v[(p + n - 1) % n] << 4)) ^ ((sum ^ y) + (k[(p ^ e) & 3] ^ v[(p + n - 1) % n]));
            // 计算加密后的数据块
        }
    }
}

解密：

/ c#

#include <stdint.h>
/* XXTEA加密算法的加密过程 */
void xxtea_encrypt(uint32_t *v, int n, uint32_t *key) {
    uint32_t y, z, sum, delta, e;
    uint32_t p, q, rounds, limit;
    uint32_t *k = key;
    rounds = 6 + 52 / n;        // 计算加密轮数
    sum = 0;
    delta = 0x9E3779B9;         // 初始化delta常数
    limit = rounds * delta;     // 计算sum的最大值
    q = 6 + limit / delta;
    while (q-- > 0) {           // 执行加密轮数
        sum += delta;           // 更新sum
        e = sum >> 2 & 3;       // 计算e值
        for (p = 0; p < n; p++) {   // 对每个数据块执行加密操作
            y = v[(p + 1) % n];
            z = v[p] += ((v[(p + n - 1) % n] >> 5) ^ (y << 2)) + ((y >> 3) ^ (v[(p + n - 1) % n] << 4)) ^ ((sum ^ y) + (k[(p ^ e) & 3] ^ v[(p + n - 1) % n]));
            // 计算加密后的数据块
        }
    }
}
/* XXTEA加密算法的解密过程 */
void xxtea_decrypt(uint32_t *v, int n, uint32_t *key) {
    uint32_t y, z, sum, delta, e;
    uint32_t p, q, rounds, limit;
    uint32_t *k = key;
    rounds = 6 + 52 / n;        // 计算加密轮数
    sum = rounds * 0x9E3779B9;  // 初始化sum常数
    delta = 0x9E3779B9;         // 初始化delta常数
    limit = rounds * delta;     // 计算sum的最大值
    q = 6 + limit / delta;
    while (q-- > 0) {           // 执行加密轮数
        e = sum >> 2 & 3;       // 计算e值
        for (p = n - 1; p > 0; p--) {   // 对每个数据块执行解密操作
            z = v[(p + n - 1) % n];
            y = v[p] -= ((v[(p + n - 1) % n] >> 5) ^ (v[(p + 1) % n] << 2)) + ((v[(p + 1) % n] >> 3) ^ (v[(p + n - 1) % n] << 4)) ^ ((sum ^ v[(p + 1) % n]) + (k[(p ^ e) & 3] ^ v[(p + n - 1) % n]));
            // 计算解密后的数据块
        }
        z = v[(n + n - 1) % n];
        y = v[0] -= ((v[(n + n - 1) % n] >> 5) ^ (v[(1) % n] << 2)) + ((v[(1) % n] >> 3) ^ (v[(n + n - 1) % n] << 4)) ^ ((sum ^ v[(1) % n]) + (k[(0 ^ e) & 3] ^ v[(n + n - 1) % n]));
        // 特殊处理第一个和最后一个数据块
        sum -= delta;           // 更新sum
    }
}