TEA家族加密
|
210
|
0
|
Encryption Algorithms

1681 字
|
8 分钟

1.前言

1.概述

TEA（Tiny Encryption Algorithm）是一种非常简单、快速的加密算法，由David Wheeler和Roger Needham于1994年设计。它采用64位分组长度和128位密钥长度，使用Feistel结构。尽管其设计简单，但其安全性和效率使其成为一个广泛使用的加密算法

2.Feistel结构

一种常见的加密设计方法（DES/AES/TEA等），广泛应用与现代加密中。

Feistel结构通过将明文分割成两个部分，并在多个轮次中反复应用特定的函数来加密数据

1.Feistel结构的基本原理

Feistel结构通过将明文分割成两个部分，并在多个轮次中反复应用特定的函数来加密数据

Feistel结构的关键特点在于，每一轮加密操作后，左右两个部分会交换位置，这样的设计可以确保加密和解密过程的对称性

2.Feistel结构的工作流程

假设明文为P，分成左右两部分L0和R0，密钥为K，则Feistel网络的每一轮加密过程如下：

  1. 初始分割：
    • 输入明文P被分割成L0和R0
    • L0表示左半部分，R0表示右半部分
  2. 轮函数：
    • 每一轮加密中，右半部分R通过一个轮函数F和密钥K进行混淆，然后与左半部分L进行XOR操作
    • 轮函数F的设计可以有所不同，通常包括一些非线性变换和混淆操作
  3. 左右交换：
    • 每一轮结束后，左半部分和右半部分交换位置，开始下一轮操作
  4. 多轮迭代：
    • 经过多轮迭代，最终得到密文

2.TEA

1.TEA加密解析

密钥：64位

密文：128位（分成4个32位的子密钥）

1.加密流程

1.传入：

64位明文，128位密钥

2.初始化：

变量 delta 被定义为一个常数 0x9E3779B9，它是黄金分割率乘以2的32次方

变量 sum 初始化为0

3.32轮迭代加密

for i in range(32):
    sum += delta
    V0 += ((V1 << 4) + K0) ^ (V1 + sum) ^ ((V1 >> 5) + K1)
    V1 += ((V0 << 4) + K2) ^ (V0 + sum) ^ ((V0 >> 5) + K3)

4.输出

密文： C=(V0,V1)

前面加密的流程是将原本的64位数据拆解成两个32位的数据

2.迭代加密解析

1.更新sum

sum += delta

2.更新v0

V0 += ((V1 << 4) + K0) ^ (V1 + sum) ^ ((V1 >> 5) + K1)
  1. V1 << 4：将 V1 左移4位（相当于乘以16）
  2. (V1 << 4) + K0：将左移后的 V1 加上子密钥 K0
  3. V1 + sum：将 V1 加上当前的 sum 值
  4. (V1 >> 5) + K1：将 V1 右移5位（相当于除以32），然后加上子密钥 K1

3.更新v1

V1 += ((V0 << 4) + K2) ^ (V0 + sum) ^ ((V0 >> 5) + K3)
  1. V0 << 4：将 V0 左移4位（相当于乘以16）
  2. (V0 << 4) + K2：将左移后的 V0 加上子密钥 K2
  3. V0 + sum：将 V0 加上当前的 sum 值
  4. (V0 >> 5) + K3：将 V0 右移5位（相当于除以32），然后加上子密钥 K3

4.示意图

          +--------+                           +--------+
          |  V0    |                           |  V1    |
          +--------+                           +--------+
              |                                    |
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        | (V1 << 4) |                       | (V0 << 4) |
        +-----------+                       +-----------+
              |                                    |
              +--------+                     +--------+
                       |                     |
          +--------+   v             +--------+   v
          |   K0   | + |             |   K2   | + |
          +--------+   |             +--------+   |
                       v                     +     v
                    +-----------------------------+
                    |  (V1 << 4) + K0             |
                    +-----------------------------+
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        | (V1 >> 5) |                       | (V0 >> 5) |
        +-----------+                       +-----------+
              |                                    |
              +--------+                     +--------+
                       |                     |
          +--------+   v             +--------+   v
          |   K1   | + |             |   K3   | + |
          +--------+   |             +--------+   |
                       v                     +     v
                    +-----------------------------+
                    |  (V1 >> 5) + K1             |
                    +-----------------------------+
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        |    sum    |                       |    sum    |
        +-----------+                       +-----------+
              |                                    |
              v                                    v
        +----------------------+        +----------------------+
        | V0 + (V1 << 4 + K0) ^|        | V1 + (V0 << 4 + K2) ^|
        | (V1 + sum) ^ (V1 >> 5|        | (V0 + sum) ^ (V0 >> 5|
        | + K1)                 |        | + K3)                 |
        +----------------------+        +----------------------+
              |                                    |
              v                                    v
          +--------+                           +--------+
          |  V0'   |                           |  V1'   |
          +--------+                           +--------+

3.加密实现

1.python实现

def tea_encrypt(v, k):
    v0, v1 = v[0], v[1]
    delta = 0x9E3779B9
    sum = 0
​
    for _ in range(32):
        sum += delta
        v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1])
        v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3])
​
    return (v0, v1)
​
def tea_decrypt(v, k):
    v0, v1 = v[0], v[1]
    delta = 0x9E3779B9
    sum = delta * 32
​
    for _ in range(32):
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3])
        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1])
        sum -= delta
​
    return (v0, v1)
​
# 示例输入
plaintext = (0x12345678, 0x9abcdef0)
key = (0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100)
​
# 加密
ciphertext = tea_encrypt(plaintext, key)
print("Ciphertext:", ciphertext)
​
# 解密
decrypted_text = tea_decrypt(ciphertext, key)
print("Decrypted text:", decrypted_text)

2.c语言实现

#include <stdint.h>
#include <stdio.h>
​
// TEA加密函数
void tea_encrypt(uint32_t v[2], uint32_t k[4]) {
    uint32_t v0 = v[0], v1 = v[1];  // 初始化，v0 和 v1 分别为明文的两个32位部分
    uint32_t sum = 0;               // 初始化 sum 为 0
    uint32_t delta = 0x9E3779B9;    // delta 是一个常数，用于增加混淆性
​
    for (int i = 0; i < 32; i++) {  // 进行32轮迭代
        sum += delta;               // 每轮迭代增加 sum 的值
        v0 += ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
        // 更新 v0 的值
        // (v1 << 4) + k[0]：将 v1 左移4位（乘以16），然后加上密钥 k[0]
        // v1 + sum：将 v1 加上 sum
        // (v1 >> 5) + k[1]：将 v1 右移5位（除以32），然后加上密钥 k[1]
        // 上述三部分进行异或操作，再加到 v0 上
​
        v1 += ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
        // 更新 v1 的值，过程类似于更新 v0 的过程
        // (v0 << 4) + k[2]：将 v0 左移4位（乘以16），然后加上密钥 k[2]
        // v0 + sum：将 v0 加上 sum
        // (v0 >> 5) + k[3]：将 v0 右移5位（除以32），然后加上密钥 k[3]
        // 上述三部分进行异或操作，再加到 v1 上
    }
​
    v[0] = v0;  // 将加密后的 v0 赋值回 v[0]
    v[1] = v1;  // 将加密后的 v1 赋值回 v[1]
}
​
int main() {
    uint32_t plaintext[2] = {0x12345678, 0x9abcdef0};  // 示例明文
    uint32_t key[4] = {0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100};  // 示例密钥
    uint32_t ciphertext[2];
​
    ciphertext[0] = plaintext[0];  // 初始化密文数组的第一个元素
    ciphertext[1] = plaintext[1];  // 初始化密文数组的第二个元素
​
    tea_encrypt(ciphertext, key);  // 调用TEA加密函数
​
    printf("Ciphertext: %08x %08x\n", ciphertext[0], ciphertext[1]);  // 打印加密后的密文
​
    return 0;
}

2.TEA解密解析

python实现

# TEA解密算法的Python实现
def tea_decrypt(v, k):
    """
    对给定的密文进行TEA解密。
    
    参数:
    v -- 密文，是一个包含两个32位整数的元组 (v0, v1)
    k -- 密钥，是一个包含四个32位整数的列表 [k0, k1, k2, k3]
    
    返回:
    解密后的明文，形式为一个包含两个32位整数的元组 (v0, v1)
    """
    v0, v1 = v  # 将密文的两个部分提取到 v0 和 v1 中
    k0, k1, k2, k3 = k  # 将密钥的四部分提取到 k0, k1, k2, k3 中
    delta = 0x9E3779B9  # delta 是加密和解密过程中使用的常量
    sum = 0xC6EF3720  # 初始化 sum 为 delta * 32 (0x9E3779B9 * 32 的结果)
​
    for _ in range(32):  # 进行32轮迭代
        v1 -= (((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3))  # 更新 v1 的值
        v0 -= (((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1))  # 更新 v0 的值
        sum -= delta  # 每轮迭代中，sum 减去 delta
    
    return (v0, v1)  # 返回解密后的明文
​
# TEA加密算法的Python实现（用于生成测试密文）
def tea_encrypt(v, k):
    """
    对给定的明文进行TEA加密。
    
    参数:
    v -- 明文，是一个包含两个32位整数的元组 (v0, v1)
    k -- 密钥，是一个包含四个32位整数的列表 [k0, k1, k2, k3]
    
    返回:
    加密后的密文，形式为一个包含两个32位整数的元组 (v0, v1)
    """
    v0, v1 = v  # 将明文的两个部分提取到 v0 和 v1 中
    k0, k1, k2, k3 = k  # 将密钥的四部分提取到 k0, k1, k2, k3 中
    delta = 0x9E3779B9  # delta 是加密和解密过程中使用的常量
    sum = 0  # 初始化 sum 为 0
    
    for _ in range(32):  # 进行32轮迭代
        sum += delta  # 每轮迭代中，sum 增加 delta
        v0 += (((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1))  # 更新 v0 的值
        v1 += (((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3))  # 更新 v1 的值
    
    return (v0, v1)  # 返回加密后的密文
​
# 示例数据
plaintext = (0x12345678, 0x9abcdef0)  # 示例明文
key = [0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100]  # 示例密钥
​
# 加密明文
ciphertext = tea_encrypt(plaintext, key)
print(f"Ciphertext: {ciphertext[0]:08x} {ciphertext[1]:08x}")
​
# 解密密文
decrypted_text = tea_decrypt(ciphertext, key)
print(f"Decrypted text: {decrypted_text[0]:08x} {decrypted_text[1]:08x}")

c语言实现

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

// TEA解密函数
void tea_decrypt(uint32_t v[2], uint32_t k[4]) {
    uint32_t v0 = v[0], v1 = v[1];  // 从密文中提取 v0 和 v1
    uint32_t sum = 0xC6EF3720;      // 初始化 sum 为 delta * 32 (0x9E3779B9 * 32 的结果)
    uint32_t delta = 0x9E3779B9;    // delta 是加密和解密过程中使用的常量

    for (int i = 0; i < 32; i++) {  // 进行32轮迭代
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
        // 更新 v1 的值
        // (v0 << 4) + k[2]：将 v0 左移4位（乘以16），然后加上密钥 k[2]
        // v0 + sum：将 v0 加上 sum
        // (v0 >> 5) + k[3]：将 v0 右移5位（除以32），然后加上密钥 k[3]
        // 上述三部分进行异或操作，然后从 v1 中减去结果

        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
        // 更新 v0 的值
        // (v1 << 4) + k[0]：将 v1 左移4位（乘以16），然后加上密钥 k[0]
        // v1 + sum：将 v1 加上 sum
        // (v1 >> 5) + k[1]：将 v1 右移5位（除以32），然后加上密钥 k[1]
        // 上述三部分进行异或操作，然后从 v0 中减去结果

        sum -= delta;  // 每轮迭代中，sum 减去 delta
    }

    v[0] = v0;  // 将解密后的 v0 保存回 v[0]
    v[1] = v1;  // 将解密后的 v1 保存回 v[1]
}

int main() {
    uint32_t ciphertext[2] = {0x2f30d1e7, 0x0eaf2ed8};  // 示例密文（用加密过程产生的结果替换）
    uint32_t key[4] = {0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100};  // 示例密钥（与加密时使用的密钥相同）
    uint32_t decrypted_text[2];

    decrypted_text[0] = ciphertext[0];  // 初始化解密数组的第一个元素
    decrypted_text[1] = ciphertext[1];  // 初始化解密数组的第二个元素

    tea_decrypt(decrypted_text, key);  // 调用TEA解密函数

    printf("Decrypted text: %08x %08x\n", decrypted_text[0], decrypted_text[1]);  // 打印解密后的明文

    return 0;
}

32轮迭代解密：

  • 通过32轮迭代逐步解密数据
  • 在每一轮中：
    • 更新 v1：计算 ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3])，然后从 v1 中减去这个值
    • 更新 v0：计算 ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1])，然后从 v0 中减去这个值
    • 更新 sum：在每轮迭代中，sum 减去 delta

3.XTEA

1.概述

XTEA（eXtended Tiny Encryption Algorithm）是对TEA（Tiny Encryption Algorithm）的改进版。它在TEA的基础上进行了优化，以提高加密的安全性和性能

2.XTEA加密解析

  • 将64位的数据块分为两个32位的数据块：v0 和 v1
  • 使用128位密钥，将其分成四个32位的子密钥：k0，k1，k2k3
  • 初始化一个名为 sum 的累计变量为0，用于控制加密轮数
  • 定义一个常量 delta，用于每轮中累积 sum

1.加密流程

1.初始化

64位的密钥提取出两个32位的密钥k0和k1

传入的64位数据分为两个32位v0和v1

2.64轮迭代/32轮迭代

对v0进行64轮加密迭代，每一轮更新v0的值，使用密钥和轮计数器进行混淆

对v1进行64轮加密迭代，每一轮更新v1 的值，使用密钥和轮计数器进行混淆

3.输出

解密后的明文是一个包含两个32位整数的元组 (v0, v1)

4.迭代加密示意图

          +--------+                           +--------+
          |  V0    |                           |  V1    |
          +--------+                           +--------+
              |                                    |
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        | (V1 << 4) |                       | (V0 << 4) |
        +-----------+                       +-----------+
              |                                    |
              +--------+                     +--------+
                       |                     |
          +--------+   v             +--------+   v
          |   K0   | + |             |   K2   | + |
          +--------+   |             +--------+   |
                       v                     +     v
                    +-----------------------------+
                    |  (V1 << 4) + K0             |
                    +-----------------------------+
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        | (V1 >> 5) |                       | (V0 >> 5) |
        +-----------+                       +-----------+
              |                                    |
              +--------+                     +--------+
                       |                     |
          +--------+   v             +--------+   v
          |   K1   | + |             |   K3   | + |
          +--------+   |             +--------+   |
                       v                     +     v
                    +-----------------------------+
                    |  (V1 >> 5) + K1             |
                    +-----------------------------+
              |                                    |
              v                                    v
        +-----------+                       +-----------+
        |    sum    |                       |    sum    |
        +-----------+                       +-----------+
              |                                    |
              v                                    v
        +----------------------+        +----------------------+
        | V0 + (V1 << 4 + K0) ^|        | V1 + (V0 << 4 + K2) ^|
        | (V1 + sum) ^ (V1 >> 5|        | (V0 + sum) ^ (V0 >> 5|
        | + K1)                 |        | + K3)                 |
        +----------------------+        +----------------------+
              |                                    |
              v                                    v
          +--------+                           +--------+
          |  V0'   |                           |  V1'   |
          +--------+                           +--------+

2.加密实现

32轮

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

#define NUM_ROUNDS 32  // XTEA的加密轮数，通常为32轮

// XTEA加密函数
void xtea_encrypt(uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1];  // 初始化两个32位数据块
    uint32_t sum = 0;  // 初始的sum为0
    uint32_t delta = 0x9e3779b9;  // 固定的delta值，通过黄金分割比计算得出

    for (unsigned int i = 0; i < NUM_ROUNDS; i++) {
        // 更新v0
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
        // 增加sum
        sum += delta;
        // 更新v1
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
    }

    v[0] = v0;  // 将加密后的结果写回输入数组
    v[1] = v1;
}

int main() {
    uint32_t v[2] = {1, 2};  // 需要加密的两个32位数据块
    uint32_t key[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210};  // 128位密钥

    printf("Before encryption: %u %u\n", v[0], v[1]);

    xtea_encrypt(v, key);

    printf("After encryption: %u %u\n", v[0], v[1]);

    return 0;
}

64轮

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

#define NUM_ROUNDS 64  // 使用64轮来增强安全性

// XTEA加密函数
void xtea_encrypt(uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1];
    uint32_t sum = 0;
    uint32_t delta = 0x9e3779b9;

    for (unsigned int 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;
}

int main() {
    uint32_t v[2] = {1, 2};
    uint32_t key[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210};

    printf("Before encryption: %u %u\n", v[0], v[1]);

    xtea_encrypt(v, key);

    printf("After encryption: %u %u\n", v[0], v[1]);

    return 0;
}

3.XTEA解密解析

1.c语言实现

32轮解密

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

#define NUM_ROUNDS 32  // XTEA的轮数

// XTEA解密函数
void xtea_decrypt(uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1];  // 初始化两个32位数据块
    uint32_t delta = 0x9e3779b9;
    uint32_t sum = delta * NUM_ROUNDS;  // 初始sum为 delta * 轮数

    for (unsigned int i = 0; i < NUM_ROUNDS; i++) {
        // 更新v1
        v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
        // 减少sum
        sum -= delta;
        // 更新v0
        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 key[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210};  // 128位密钥

    // 加密后的密文
    uint32_t encrypted_v[2] = {3040415744, 861393672};  // 假设已知的加密后的数据

    printf("Before decryption: %u %u\n", encrypted_v[0], encrypted_v[1]);

    // 调用解密函数
    xtea_decrypt(encrypted_v, key);

    printf("After decryption: %u %u\n", encrypted_v[0], encrypted_v[1]);

    return 0;
}

64轮解密

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

#define NUM_ROUNDS 64  // 使用64轮来增强安全性

// XTEA解密函数
void xtea_decrypt(uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1];
    uint32_t delta = 0x9e3779b9;
    uint32_t sum = delta * NUM_ROUNDS;  // 初始sum为 delta * 轮数

    for (unsigned int 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 key[4] = {0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210};  // 128位密钥

    // 加密后的密文
    uint32_t encrypted_v[2] = {3040415744, 861393672};  // 假设已知的加密后的数据

    printf("Before decryption: %u %u\n", encrypted_v[0], encrypted_v[1]);

    // 调用解密函数
    xtea_decrypt(encrypted_v, key);

    printf("After decryption: %u %u\n", encrypted_v[0], encrypted_v[1]);

    return 0;
}

2.python实现

可以将rounds更改即可对应32位和64位

def xtea_decrypt(v, key, rounds=32):
    v0, v1 = v
    delta = 0x9e3779b9
    sum_val = delta * rounds

    for _ in range(rounds):
        v1 -= ((v0 << 4) ^ (v0 >> 5)) + v0 ^ (sum_val + key[sum_val & 3])
        sum_val -= delta
        v0 -= ((v1 << 4) ^ (v1 >> 5)) + v1 ^ (sum_val + key[(sum_val >> 11) & 3])
        sum_val -= delta

    return v0, v1

# 测试代码
v = [3040415744, 861393672]
key = [0x01234567, 0x89abcdef, 0xfedcba98, 0x76543210]

# 32轮解密示例
result_32 = xtea_decrypt(v, key, rounds=32)
print(f"32-round decrypted result: {result_32}")

# 64轮解密示例
result_64 = xtea_decrypt(v, key, rounds=64)
print(f"64-round decrypted result: {result_64}")

4.XXTEA

1.概述

XXTEA（Corrected Block TEA）是一种对TEA（Tiny Encryption Algorithm）进行改进后的块加密算法，基于Feistel网络结构的变种，主要通过反复迭代和数据块之间的相互依赖来实现数据的混淆和扩散，每个数据块之间的操作都会影响到下一个数据块，从而提高了整体的加密强度

2.XXTEA加密解析

1.关键点

1.输入

包含32个数据块的数组v

128位密钥（分成k0，k1，k2，k3）

2.常量

delta：跟前面一样一个固定的32位常量 0x9E3779B9

sum：初始化为0

3.核心计算公式

MX = ((z>>5 ^ y<<2) + (y>>3 ^ z<<4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z))
  • z 和 y 是相邻的数据块
  • p 是当前数据块的索引
  • e 是当前轮次的索引
  • k 是密钥数组

2.加密流程

1.初始化

将输入数据块数组 V 和密钥数组 K 进行预处理

2.迭代加密

对数据块数组 V 进行多轮迭代操作：

  • 计算当前轮次的 sum 值
  • 计算当前轮次的 MX 值，并更新每个数据块

3.输出

最终的加密结果是更新后的数据块数组 `V

3.加密理解

1.加密的伪代码

便于理解

function xxtea_encrypt(V, K):
    n = length(V)
    delta = 0x9E3779B9
    sum = 0
    rounds = 6 + 52/n

    while rounds > 0:
        sum += delta
        e = (sum >> 2) & 3

        for p = 0 to n-2:
            y = V[p+1]
            z = V[p]
            V[p] += MX
            z = y

        y = V[0]
        z = V[n-1]
        V[n-1] += MX

        rounds -= 1

    return V

2.迭代算法示意图

          +---------+---------+---------+---------+
          |    V0   |    V1   |    V2   |    V3   |  ... (多个32位数据块)
          +---------+---------+---------+---------+
                |         |         |         |
                v         v         v         v
         +---------+  +---------+  +---------+  +---------+
         | sum = 0 |  | sum = 0 |  | sum = 0 |  | sum = 0 |
         +---------+  +---------+  +---------+  +---------+
                |         |         |         |
                v         v         v         v
        +------------------------------------------------+
        |                sum += delta                   |
        +------------------------------------------------+
                |         |         |         |
                v         v         v         v
      +--------------+  +--------------+  +--------------+  +--------------+
      | V0 += MX(Vn) |  | V1 += MX(V0) |  | V2 += MX(V1) |  | V3 += MX(V2) |
      +--------------+  +--------------+  +--------------+  +--------------+
                |         |         |         |
                v         v         v         v
     +------------------------------------------------------+
     | V0' |    V1'    |    V2'    |    V3'    | ... (更新后的数据块)|
     +------------------------------------------------------+

重复上述步骤，直到完成所有轮次的迭代。

4.加密实现

#include <stdint.h>

#define MX (((z>>5 ^ y<<2) + (y>>3 ^ z<<4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z)))

void xxtea_encrypt(uint32_t *v, int n, const uint32_t *k) {
    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 += 0x9E3779B9;
            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);
    }
}

3.XXTEA解密实现

c语言实现

#include <stdint.h>

// 定义计算公式 MX
// z 和 y 是相邻的数据块
// p 是当前数据块的索引
// e 是当前轮次的索引
// k 是密钥数组
#define MX (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z)))

// XXTEA解密函数
// v 是数据块数组
// n 是数据块数量
// k 是密钥数组
void xxtea_decrypt(uint32_t *v, int n, const uint32_t *k) {
    uint32_t y, z, sum;
    unsigned p, rounds, e;
    
    // 检查数据块数量是否大于1
    if (n > 1) {          
        // 计算迭代轮数
        rounds = 6 + 52 / n;
        // 初始化 sum 为轮数乘以 delta
        sum = rounds * 0x9E3779B9;
        // 初始化 y 为第一个数据块
        y = v[0];
        
        // 迭代解密过程
        do {
            // 计算当前轮次的 e 值
            e = (sum >> 2) & 3;
            
            // 从最后一个数据块到第一个数据块进行更新
            for (p = n - 1; p > 0; p--) {
                z = v[p - 1]; // z 是上一个数据块的值
                y = v[p];     // y 是当前数据块的值
                // 使用 MX 公式计算更新后的值，并从当前数据块中减去结果
                v[p] -= MX;
            }
            
            // 处理第一个数据块
            z = v[n - 1];
            y = v[0];
            // 使用 MX 公式计算更新后的值，并从第一个数据块中减去结果
            v[0] -= MX;
            
            // 每轮结束时，将 sum 减去 delta
        } while ((sum -= 0x9E3779B9) != 0);
    }
}
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																				
					
											
						

	

		
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
	

	

		
颜文字
Emoji
小恐龙
花!
	


									

			

			
			
		

	






上一篇
下一篇