V0 += (((V1 << 4) ^ (V1 >> 5)) + V1) ^ (sum + K[sum & 3])

sum += delta

V1 += (((V0 << 4) ^ (V0 >> 5)) + V0) ^ (sum + K[(sum >> 11) & 3])

1. 增加了迭代轮数：TEA算法迭代轮数为32轮，XTEA算法增加到了64轮，加强了加密强度。

__int64 __fastcall tea_encrypt(unsigned int *a1, __int64 a2){  __int64 result; // rax  unsigned __int64 i; // [rsp+8h] [rbp-18h]  unsigned int v4; // [rsp+14h] [rbp-Ch]  unsigned int v5; // [rsp+18h] [rbp-8h]  unsigned int v6; // [rsp+1Ch] [rbp-4h]
  v6 = *a1;  v5 = a1[1];  v4 = 0;  for ( i = 0i64; i <= 0x1F; ++i )  {    v6 += (((v5 >> 5) ^ (16 * v5)) + v5) ^ (*(_DWORD *)(4i64 * (v4 & 3) + a2) + v4);    v4 -= 1640531527;    v5 += (((v6 >> 5) ^ (16 * v6)) + v6) ^ (*(_DWORD *)(4i64 * ((v4 >> 11) & 3) + a2) + v4);  }  *a1 = v6;  result = v5;  a1[1] = v5;  return result;}

RC4算法的解密过程与加密过程相同，因为异或运算是可逆的。

需要注意的是，RC4算法的密钥长度不应太短，否则容易受到攻击。通常建议使用长度为128位或以上的密钥。此外，RC4算法在初始化时需要避免使用相同的密钥和初始化向量，否则会导致生成的伪随机比特流重复，从而降低加密强度。

   关键变量

1. 密钥流：RC4算法的关键是根据明文和密钥生成相应的密钥流，密钥流的长度和明文的长度是对应的，也就是说明文的长度是500字节，那么密钥流也是500字节。当然，加密生成的密文也是500字节，因为密文第i字节=明文第i字节^密钥流第i字节；

2. 状态向量S：长度为256，S[0],S[1].....S[255]。每个单元都是一个字节，算法运行的任何时候，S都包括0-255的8比特数的排列组合，只不过值的位置发生了变换；

3. 临时向量T：长度也为256，每个单元也是一个字节。如果密钥的长度是256字节，就直接把密钥的值赋给T，否则，轮转地将密钥的每个字节赋给T；

4. 密钥K：长度为1-256字节，注意密钥的长度keylen 与明文长度、密钥流的长度没有必然关系，通常密钥的长度趣味16字节（128比特）。

   三步加密

初始化S和T

int Len = strlen(key); for(i=0;i<256;i++) {        s[i]=i;        T[i]=key[i%Len];    }

初始化排列S

for(i=0;i<256;i++) {        j=(j+s[i]+k[i])%256;        tmp=s[i];        s[i]=s[j];//交换s[i]和s[j]        s[j]=tmp;    }

产生密钥流

int i=0,j=0,t=0;unsigned long k=0;unsigned char tmp;for(k=0;k < len;k++){    i=(i+1)%256;    j=(j+s[i])%256;    tmp=s[i];    s[i]=s[j]; //交换s[x]和s[y]    s[j]=tmp;}

流程图

                +------------+            +--->| Initialize |            |    +------------+            |          |            |          | (K)            |          v            |    +------------+            |    | Key-scheduling |            |    +------------+            |          |            |          | (P)            |          v            |    +------------+            +--->|  Encryption  |                 +------------+                      |                      v                 +------------+                 |  Output CT  |                 +------------+

   完整加密解密程序

//程序开始#include<stdio.h>#include<string.h>typedef unsigned longULONG; /*初始化函数*/void rc4_init(unsigned char*s, unsigned char*key, unsigned long Len){    int i = 0, j = 0;    char k[256] = { 0 };    unsigned char tmp = 0;    for (i = 0; i<256; i++)    {        s[i] = i;        k[i] = key[i%Len];    }    for (i = 0; i<256; i++)    {        j = (j + s[i] + k[i]) % 256;        tmp = s[i];        s[i] = s[j];//交换s[i]和s[j]        s[j] = tmp;    }} /*加解密*/void rc4_crypt(unsigned char*s, unsigned char*Data, unsigned long Len){    int i = 0, j = 0, t = 0;    unsigned long k = 0;    unsigned char tmp;    for (k = 0; k<Len; k++)    {        i = (i + 1) % 256;        j = (j + s[i]) % 256;        tmp = s[i];        s[i] = s[j];//交换s[x]和s[y]        s[j] = tmp;        t = (s[i] + s[j]) % 256;        Data[k] ^= s[t];    }} int main(){    unsigned char s[256] = { 0 }, s2[256] = { 0 };//S-box    char key[256] = { "justfortest" };    char pData[512] = "这是一个用来加密的数据Data";    unsigned long len = strlen(pData);    int i;     printf("pData=%s\n", pData);    printf("key=%s,length=%d\n\n", key, strlen(key));    rc4_init(s, (unsigned char*)key, strlen(key));//已经完成了初始化    printf("完成对S[i]的初始化，如下：\n\n");    for (i = 0; i<256; i++)    {        printf("%02X", s[i]);        if (i && (i + 1) % 16 == 0)putchar('\n');    }    printf("\n\n");    for (i = 0; i<256; i++)//用s2[i]暂时保留经过初始化的s[i]，很重要的！！！    {        s2[i] = s[i];    }    printf("已经初始化，现在加密:\n\n");    rc4_crypt(s, (unsigned char*)pData, len);//加密    printf("pData=%s\n\n", pData);    printf("已经加密，现在解密:\n\n");    //rc4_init(s,(unsignedchar*)key,strlen(key));//初始化密钥    rc4_crypt(s2, (unsigned char*)pData, len);//解密    printf("pData=%s\n\n", pData);    return 0;} //程序完

   常见题型以及解答

RC4的加密解密问题分为两种方式，因为我们可以发现rc4其中欧冠的初始化S,T与初始化排列S盒都是与我们需要加密的密钥无关的，最终与加密原文有关的只有最后一段的异或。因此RC4题型给出两种解答方法。

这里利用例题来讲解:[Reverse]crypt

(https://shangwendada.co/index.php/2022/11/09/reversecryptrc4/)

动态调试取异或值

我们将上文中写到的加密脚本编译后放入ida中观察。

可以看到rc4的特点就是通常使用两个加密函数，一个用来初始化S盒与T盒，另一个则用来将明文与密钥流异或。

因此我们只需要在异或处下断点然后拿出寄存器中的值与密文异或就能够解决问题。

常规脚本解法

常规脚本就是复制粘贴下题目的加密解密函数，将题目中的加密函数复制下来，然后直接使用就行，这里贴出例题中的解密脚本

#include<stdio.h>#include<windows.h>#include<cstring>using namespace std; char key[] ={  0x9E, 0xE7, 0x30, 0x5F, 0xA7, 0x01, 0xA6, 0x53, 0x59, 0x1B,   0x0A, 0x20, 0xF1, 0x73, 0xD1, 0x0E, 0xAB, 0x09, 0x84, 0x0E,   0x8D, 0x2B, 0x00, 0x00};char Str[]="12345678abcdefghijklmnopqrspxyz";__int64 __fastcall sub_140001120(DWORD *a1, char *a2, int a3){  __int64 result; // rax  int i; // [rsp+0h] [rbp-28h]  int j; // [rsp+0h] [rbp-28h]  int v6; // [rsp+4h] [rbp-24h]  int v7; // [rsp+8h] [rbp-20h]  int v8; // [rsp+Ch] [rbp-1Ch]  DWORD *v9; // [rsp+10h] [rbp-18h]   *a1 = 0;  a1[1] = 0;  v9 = a1 + 2;  for ( i = 0; i < 256; ++i )    v9[i] = i;  v6 = 0;  result = 0;  v7 = 0;  for ( j = 0; j < 256; ++j )  {    v8 = v9[j];    v7 = (unsigned __int8)(*(BYTE *)(a2 + v6) + v8 + v7);    v9[j] = v9[v7];    v9[v7] = v8;    if ( ++v6 >= a3 )      v6 = 0;    result = (unsigned int)(j + 1);  }  return result;}DWORD sub_140001240(DWORD *a1, char* a2, int a3){  DWORD *result; // rax  int i; // [rsp+0h] [rbp-28h]  int v5; // [rsp+4h] [rbp-24h]  int v6; // [rsp+8h] [rbp-20h]  int v7; // [rsp+Ch] [rbp-1Ch]  int v8; // [rsp+10h] [rbp-18h]  DWORD *v9; // [rsp+18h] [rbp-10h]   v5 = *a1;  v6 = a1[1];  v9 = a1 + 2;  for ( i = 0; i < a3; ++i )  {    v5 = (unsigned __int8)(v5 + 1);    v7 = v9[v5];    v6 = (unsigned __int8)(v7 + v6);    v8 = v9[v6];    v9[v5] = v8;    v9[v6] = v7;    *(BYTE *)(a2 + i) ^= LOBYTE(v9[(unsigned __int8)(v8 + v7)]);  }  *a1 = v5;  result = a1;  a1[1] = v6;}int i;int main(){    DWORD *v9;    v9=(DWORD *)malloc(0x408*sizeof(v9));    sub_140001120(v9,Str,strlen(Str));    for(int i = 0 ; i < strlen(key);i ++  )    {        key[i]^=34;    }    sub_140001240(v9,key,strlen(key));    printf("%s",key);}

注意

RC4出题中，伪比特流的产生方法不唯一，也就是说S盒与T盒的制作方法不会唯一，存在较大的魔改空间。

[由于该加密方式考的比较少,此处不深入研究]

ChaCha20是一种流密码算法，用于加密和解密数据流。它由Daniel J. Bernstein于2008年设计，是Salsa20的改进版，被广泛应用于网络通信、加密文件和存储介质等领域。

ChaCha20算法使用256位的密钥和一个12字节的随机数（称为nonce）作为输入，生成一个可变长度的伪随机比特流，然后与明文进行异或运算得到密文。ChaCha20算法的特点是快速、安全、易于实现和内存友好，适用于高速网络通信和移动设备。

   与RC4的区别

眼尖的可能发现了，chacha20也是使用伪随机比特流来产生密钥的，然后将密钥与明文异或进行加密，接下来就讲讲他们在安全性下的区别吧。

Chacha20和RC4都是流密码算法，但它们的加密原理有以下几个区别：

1. 密钥长度：Chacha20的密钥长度为256位（32字节），而RC4的密钥长度为1到256字节不等。因此，Chacha20可以提供更强的密钥安全性，也更适合用于现代加密应用。

2. S盒：Chacha20没有S盒，而RC4使用一个256字节的S盒来生成密钥流。Chacha20是基于置换的加密算法，它使用固定的置换来生成密钥流。

3. 加密过程：在Chacha20中，通过对输入的明文数据块进行置换和加密操作，生成密文输出。每次加密需要根据密钥和计数器生成一个新的置换和密钥流。而RC4是在密钥生成完毕后，直接用密钥流对输入的明文进行异或操作得到密文输出。

4. 安全性：由于RC4存在一些安全性问题，它已经不被推荐使用。而Chacha20已经被广泛应用于TLS、SSH、IPsec等加密通信协议中，并且其安全性得到了广泛认可。

综上所述，Chacha20相比于RC4，具有更高的密钥安全性和更好的安全性保障，更加适合用于现代加密应用。

   加密步骤

ChaCha20算法的加密过程如下：

1. 初始化：使用密钥和随机数生成初始状态。

2. 生成伪随机比特流：使用初始状态和计数器生成伪随机比特流。

3. 明文加密：将明文与伪随机比特流进行异或运算得到密文。

4. 重复步骤2和3：使用相同的密钥和随机数对每个数据块重复执行步骤2和3。

ChaCha20算法的解密过程与加密过程相同，因为异或运算是可逆的。

需要注意的是，ChaCha20算法的密钥长度不应太短，否则容易受到攻击。通常建议使用长度为256位的密钥。此外，随机数在每次使用时应该是不同的，否则会导致生成的伪随机比特流重复，从而降低加密强度。

以下是一个使用Python 3实现ChaCha20加密的示例脚本：

import structimport hashlib
def chacha20_encrypt(key, nonce, plaintext):    # 生成初始状态    state = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]    state += struct.unpack('<4I', key)    state += [0] * 4    state += struct.unpack('<3I', nonce) + [0]
    # 生成伪随机比特流    def quarterround(a, b, c, d):        state[a] += state[b]        state[d] ^= state[a]        state[d] = (state[d] << 16) | (state[d] >> 16)        state[c] += state[d]        state[b] ^= state[c]        state[b] = (state[b] << 12) | (state[b] >> 20)        state[a] += state[b]        state[d] ^= state[a]        state[d] = (state[d] << 8) | (state[d] >> 24)        state[c] += state[d]        state[b] ^= state[c]        state[b] = (state[b] << 7) | (state[b] >> 25)
    buf = bytearray(plaintext)    for i in range(0, len(buf), 64):        x = state[:]        for j in range(10):            quarterround(0, 4, 8, 12)            quarterround(1, 5, 9, 13)            quarterround(2, 6, 10, 14)            quarterround(3, 7, 11, 15)            quarterround(0, 5, 10, 15)            quarterround(1, 6, 11, 12)            quarterround(2, 7, 8, 13)            quarterround(3, 4, 9, 14)        for j in range(16):            x[j] += state[j]            buf[i+j] ^= (x[j] & 0xff)            buf[i+j+1:i+j+4] = bytes([((x[j] >> k) & 0xff) for k in (8, 16, 24)])
    return bytes(buf)
# 示例用法key = hashlib.sha256(b'my secret key').digest()nonce = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'plaintext = b'hello world'ciphertext = chacha20_encrypt(key, nonce, plaintext)print(ciphertext.hex())

该脚本中的chacha20_encrypt函数接收密钥、随机数和明文作为输入，返回加密后的密文。实现中使用了Python标准库中的struct模块和bytearray类型来处理二进制数据。

例题

为什么这里讲到了chacha20，因为在Hgame的比赛中出现了该题，解出的人还是比较少的，这里讲讲

chacha20这里推荐直接dump密钥来进行getflag

from idaapi import get_reg_valprint(get_reg_val('ecx'),end=",")

这里使用idapython直接调取寄存器的值

解密脚本就是如下:

int main(){    unsigned int key[] = {    1077387342,4258923078,1013905953,3483163055,1731413945,233590496,327206097,9847    87250,39669927,2202679682    };    unsigned char v2[40];    v2[0] = 0x28;    v2[1] = 0x50;    v2[2] = -63;    v2[3] = 35;    v2[4] = -104;    v2[5] = -95;    v2[6] = 65;    v2[7] = 54;    v2[8] = 76;    v2[9] = 49;    v2[10] = -53;    v2[11] = 82;    v2[12] = -112;    v2[13] = -15;    v2[14] = -84;    v2[15] = -52;    v2[16] = 15;    v2[17] = 108;    v2[18] = 42;    v2[19] = -119;    v2[20] = 127;    v2[21] = -33;    v2[22] = 17;    v2[23] = -124;    v2[24] = 127;    v2[25] = -26;    v2[26] = -94;    v2[27] = -32;    v2[28] = 89;    v2[29] = -57;    v2[30] = -59;    v2[31] = 70;    v2[32] = 93;    v2[33] = 41;    v2[34] = 56;    v2[35] = -109;    v2[36] = -19;    v2[37] = 21;    v2[38] = 122;    v2[39] = -1;    for (int i = 0; i < 10; i++)    {        putchar(v2[i*4 + 0] ^ (key[i] >> 24));        putchar(v2[i*4 + 1] ^ (key[i] >> 16));        putchar(v2[i*4 + 2] ^ (key[i] >> 8));        putchar(v2[i*4 + 3] ^ (key[i] >> 0));    }}

ROT(简单)

由于比较简单,这里不深入研究

ROT加密，也称为“字母位移加密”或“移位加密”，是一种简单的加密算法。它通过将明文中的每个字母按照一定规则进行移位操作来生成密文，常用于简单的加密需求或者编码中。

ROT加密的原理非常简单，只需要将明文中的每个字母按照一定的规则向右移动指定的位数，得到对应的密文。具体来说，如果移位数为N，则明文中的字母A会被替换成第N个字母，B会被替换成第N+1个字母，以此类推。如果移位数为26（即字母表的总长度），则加密后的密文就是明文的一种循环置换。

ROT加密算法的弱点在于它的加密过程非常简单，容易被破解。而且，ROT加密算法只适用于纯文本的加密，不适用于加密数字、二进制等其他数据类型。

   举例

以下是一个简单的Python实现ROT13加密的例子：

def rot13(s):    result = ''    for c in s:        if 'a' <= c <= 'z':            result += chr((ord(c) - ord('a') + 13) % 26 + ord('a'))        elif 'A' <= c <= 'Z':            result += chr((ord(c) - ord('A') + 13) % 26 + ord('A'))        else:            result += c    return result

在这个例子中，我们将字母按照ROT13的规则进行移位操作。对于明文中的每个字母，如果它是一个小写字母，则将其移动13个位置，如果是一个大写字母，则也将其移动13个位置。对于非字母字符，我们直接将其保留。最后返回加密后的密文字符串。

BASE64以及换表

BASE64属于是入门级别的东西了，这里只需要发现base64的加密解密函数就能发现base64加密

类似于下图:

   换表

这里直接分享一个换表的脚本:

import base64import string
str1 = "AMHo7dLxUEabf6Z3PdWr6cOy75i4fdfeUzL17kaV7rG=" #待解秘字符串
string1 = "qaCpwYM2tO/RP0XeSZv8kLd6nfA7UHJ1No4gF5zr3VsBQbl9juhEGymc+WTxIiDK" #新表string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
print (base64.b64decode(str1.translate(str.maketrans(string1,string2))))

顺便分享一个c++版本的

#include<iostream>#include<cstring>#include<bitset>#include<vector>#include<stdlib.h>#include<time.h>#include<sstream>#include<cstring>/*base64.c*/  #include "base64.h"  using namespace std; //base64.c#include"base64.h"char base64char[] = {        'A','B','C','D','E','F','G','H','I','J',        'K','L','M','N','O','P','Q','R','S','T',        'U','V','W','X','Y','Z','a','b','c','d',        'e','f','g','h','i','j','k','l','m','n',        'o','p','q','r','s','t','u','v','w','x',        'y','z','0','1','2','3','4','5','6','7',        '8','9','+', '/', '\0'};/*char base64char[] = {                'K','L','M','N','O','P','Q','R','S','T',        'A','B','C','D','E','F','G','H','I','J',        'e','f','g','h','i','j','k','l','m','n',        'U','V','W','X','Y','Z','a','b','c','d',        'o','p','q','r','s','t','u','v','w','x',        'y','z','0','1','2','3','4','5','6','7',        '8','9','+', '/', '\0'};*/char c;
void Menu(){    printf("***************\n");    printf("*1、base64加密\n");    printf("*2、base64解密\n");    printf("*3、退出程序\n");    printf("***************\n");}
char* base64_encode(char* binData, char* base64, int binLength){    int i = 0;    int j = 0;    int current = 0;    for (i = 0; i < binLength; i += 3) {        //获取第一个6位        current = (*(binData + i) >> 2) & 0x3F;        *(base64 + j++) = base64char[current];        //获取第二个6位的前两位        current = (*(binData + i) << 4) & 0x30;        //如果只有一个字符，那么需要做特殊处理        if (binLength <= (i + 1)) {            *(base64 + j++) = base64char[current];            *(base64 + j++) = '=';            *(base64 + j++) = '=';            break;        }        //获取第二个6位的后四位        current |= (*(binData + i + 1) >> 4) & 0xf;        *(base64 + j++) = base64char[current];        //获取第三个6位的前四位        current = (*(binData + i + 1) << 2) & 0x3c;        if (binLength <= (i + 2)) {            *(base64 + j++) = base64char[current];            *(base64 + j++) = '=';            break;        }        //获取第三个6位的后两位        current |= (*(binData + i + 2) >> 6) & 0x03;        *(base64 + j++) = base64char[current];        //获取第四个6位        current = *(binData + i + 2) & 0x3F;        *(base64 + j++) = base64char[current];    }    *(base64 + j) = '\0';    return base64;}
unsigned char * base64_decode(char const* base64Str,unsigned char* debase64Str, int encodeStrLen){    int i = 0;    int j = 0;    int k = 0;    char temp[4] = "";
    for (i = 0; i < encodeStrLen; i += 4) {        for (j = 0; j < 64; j++) {            if (*(base64Str + i) == base64char[j]) {                temp[0] = j;            }        }                for (j = 0; j < 64; j++) {            if (*(base64Str + i + 1) == base64char[j]) {                temp[1] = j;            }        }
        for (j = 0; j < 64; j++) {            if (*(base64Str + i + 2) == base64char[j]) {                temp[2] = j;            }        }
        for (j = 0; j < 64; j++) {            if (*(base64Str + i + 3) == base64char[j]) {                temp[3] = j;            }        }
        *(debase64Str + k++) = ((temp[0] << 2) & 0xFC) | ((temp[1] >> 4) & 0x03);        if (*(base64Str + i + 2) == '=')            break;
        *(debase64Str + k++) = ((temp[1] << 4) & 0xF0) | ((temp[2] >> 2) & 0x0F);        if (*(base64Str + i + 3) == '=')            break;
        *(debase64Str + k++) = ((temp[2] << 6) & 0xF0) | (temp[3] & 0x3F);    }    return debase64Str;}
int main(){  char ad[]="wr3ClVcSw7nCmMOcHcKgacOtMkvDjxZ6asKWw4nChMK8IsK7KMOOasOrdgbDlx3DqcKqwr0hw701Ly57w63CtcOl"; unsigned char add[256]={0}; base64_decode(ad,add,88); for(int i = 0 ; i <88;  i++ ) {  printf("0x%x,",add[i]); } /* for(int i = 0 ; i < strlen(base64char);i++) {  printf("%c",base64char[i]); } */}

总结

以上就是我常在ctf逆向中遇到的加密解密内容了，本篇文章偏向于新手向，内容还是比较详细的，希望能给大家带来帮助。