国成杯&polar碎碎念

国成杯赛后复盘

额，总结就是在做 apk 的时候，那半自动化脚本给我搓破防了，而且有点神志不清了，看下文吧…..

Crush’s_secret

遇到这种smc我一般都是动调过去，然后按个p重新反编译就行,不多讲了，贴个原生态xxtea脚本吧

#include <stdio.h>
#include <stdint.h>
#define DELTA -0x61C88647   //改
#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)
	{
		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)
	{
		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()
{
	/*
	原数据为：				传进去的参数为：
	0xbc 0xa5 0xce 0x40		->0x40cea5bc
	0xf4 0xb2 0xb2 0xe7		->0xe7b2b2f4
	0xa9 0x12 0x9d 0x12		->0x129d12a9
	0xae 0x10 0xc8 0x5b		->0x5bc810ae
	0x3d 0xd7 0x06 0x1d		->0x1d06d73d
	0xdc 0x70 0xf8 0xdc		->0xdcf870dc
	*/
	uint32_t v[12] = {0 };

	v[0] = 0x5A764F8A;
	v[1] = 0x5B0DF77;
	v[2] = 0xF101DF69;
	v[3] = 0xF9C14EF4;
	v[4] = 0x27F03590;
	v[5] = 0x7DF3324F;
	v[6] = 0x2E322D74;
	v[7] = 0x8F2A09BC;
	v[8] = 0xABE2A0D7;
	v[9] = 0xC2A09FE;
	v[10] = 0x35892BB2;
	v[11] = 0x53ABBA12;

	/*
	密钥为字符串"flag"
	十六进制表示为 0x66 0x6c 0x61 0x67
	于是传进去的参数要转换成 0x67616c66
	由于密钥长度为128位，其余需填充0
	*/
	uint32_t const k[4] = {
		(unsigned int)0x5201314, (unsigned int)0x52013140,
		(unsigned int)0x5201314, (unsigned int)0x52013140 };

	//n的绝对值表示v的长度，取正表示加密，取负表示解密
	int n = sizeof(v) / sizeof(uint32_t);    //

	//printf("加密前原始数据：0x%x 0x%x\n", v[0], v[1]);
	//btea(v, n, k);
	//printf("加密后的数据：0x%x 0x%x\n", v[0], v[1]);
	btea(v, -2, k);     //这里跟ida的改
	printf("解密后的数据：0x%x 0x%x\n", v[0], v[1]);
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < sizeof(uint32_t) / sizeof(uint8_t); j++)
		{
			printf("%c", (v[i] >> (j * 8)) & 0xFF);
		}
	}
	printf("\n");
	return 0;
}
//半自动化

round

欸，又是被dfs算法卡住的一集

先讲怎么过username

android:debuggable="true"
android:extractNativeLibs="true"

mt管理器改上，保存，签名不过的话自己签一个就行，然后输入1111111111调试，发现加密后和cyber对比中间两位对调，问题不大

然后讲后面的passport

有个makebox,可以调起来来，或者直接嗦ai，记得看一下对比

然后开始最头疼的一集，给大家看看我的goushi半自动化脚本

#include <stdio.h>
#include <string.h>
#define PASSWORD_LENGTH 12

#define ARRAY_SIZE 1024

#define MAX_LENGTH 1024
#define TARGET_LENGTH 12
// 字符集的大小
#define CHARSET_SIZE 62 // 26 (a-z) + 26 (A-Z) + 1 (_)

// 定义字符集
const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_";
void makebox(const char* str, int* iArr) {
    // 步骤 1: 初始化 iArr 数组
    for (int i = 0; i < ARRAY_SIZE; i++) {
        iArr[ARRAY_SIZE - 1 - i] = i;
    }

    // 步骤 2: 对数组每个元素进行 XOR 操作
    int strLength = strlen(str);
    for (int i = 0; i < ARRAY_SIZE; i++) {
        iArr[i] ^= str[i % strLength];  // 按位异或
    }
}

void printArray(int* arr) {
    for (int i = 0; i < ARRAY_SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    char str[] = "c9m1bRmfY5Wk";  // 请在此处替换你的字符串
    int iArr[ARRAY_SIZE];

    // 执行 Makebox 操作
    makebox(str, iArr);

    // 打印结果
    printArray(iArr);
    int iArr2[12];
    int iArr3[] = { 352, 646, 752, 882, 65, 0, 122, 0, 0, 7, 350, 360 };
    unsigned int i = 33;


    for (int j = 32; j < 128; j++)
    {
        i = 86;   //该
        int charAt = j;
        for (int i3 = 0; i3 < 32; i3++) {
            int i4 = (((iArr[i] ^ charAt) % 5) + 5) % 5;
            //printf("this %d i4 = %d", i3, i4);
            if (i4 == 0) {
                //ada = add(iArr, charAt, i);
                charAt = ((charAt + iArr[i]) % 0x400 + 0x400) % 0x400;
                i = (i + charAt) % 0x400;


            }
            else if (i4 == 1) {
                //ada = sub(iArr, charAt, i);
                charAt = ((charAt - iArr[i]) % 0x400 + 0x400) % 0x400;
                i = (i + charAt) % 0x400;

            }
            else if (i4 == 2) {
                //ada = xorOperation(iArr, charAt, i);
                charAt = (iArr[i] ^ charAt) % 0x400;
                i = (i + charAt) % 0x400;

            }
            else if (i4 == 3) {
                //ada = shl(charAt, i);
                charAt = (charAt >> 3) % 0x400;
                i = (i + charAt) % 0x400;

            }
            else if (i4 == 4) {
                //ada = shr(charAt, i);
                charAt = (charAt << 3) % 0x400;
                i = (i + charAt) % 0x400;
            }
        }
        if (charAt == 350)  //该
        {
            printf("%x ", j);
            printf("%d ", i);     //从这里取新i再在上面改
            //0x7a, 0, 0, 7, 350, 360
            //5f 795 646 _
            // 72 887 752 r
            // 6f 962 882 o
            //75 638 65 u
            //6e 243 0 
            //44 468 0x7a 
            //5f 992 0
            //zheli 4d 807 50 46 0
        }
    }                                                                            
    return 0;
}

欸，所以还得是dfs

python版，从哈工大师傅的wp偷的

def makebox(s):
    iArr = [1023-i for i in range(1024)]
    for i in range(1024):
        iArr[i] = iArr[i] ^ ord(s[i%12])
    return iArr;

box = makebox("c9m1bRmfY5Wk") # round_and

def round(iArr, str):
    length = len(str)
    iArr2 = [0 for _ in range(length)] 
    iArr3 = [352, 646, 752, 882, 65, 0, 122, 0, 0, 7, 350, 360]
    i = 33
    for i2 in range(0, length):
        charAt = ord(str[i2])
        for _ in range(0, 32):
            i4 = (iArr[i] ^ charAt) % 5
            if i4 == 0:
                charAt = (charAt + iArr[i]) % 1024
                i = (i + charAt) % 1024
            if i4 == 1:
                charAt = (charAt - iArr[i]) % 1024
                i = (i + charAt) % 1024
            if i4 == 2:
                charAt = (charAt ^ iArr[i]) % 1024
                i = (i + charAt) % 1024
            if i4 == 3:
                charAt = (charAt >> 3) % 1024
                i = (i + charAt) % 1024
            if i4 == 4:
                charAt = (charAt << 3) % 1024
                i = (i + charAt) % 1024
        iArr2[i2] = charAt
    # print(iArr2)
    # print(iArr3)
    return iArr2
import string
dic = string.ascii_letters+'_'
print(dic)
iArr3 = [352, 646, 752, 882, 65, 0, 122, 0, 0, 7, 350, 360]
idx = 0
ans = ''

def dfs(idx, ans):
    if idx == len(iArr3):
        print(ans) # _rounD_we_go
        return
    for i in dic:  # 遍历所有可能的字符
        res = round(box, ans+i) 
        if res[-1] == iArr3[idx]: #逐位字符比较
            # print(ans+i)
            dfs(idx+1, ans+i)
dfs(0, '')
# print(ans)

C语言版，showmaker师傅友情泄露

欸？他base64脚本也挺好的，全偷了o_0

#include <stdio.h>
#include <string.h>

unsigned char s[] = "c9m1bRmfY5Wk";
unsigned char table[] = 
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

unsigned char findchar(unsigned char c)
{
    for (int i = 0; i < 64; i++) {
        if (table[i] == c) {
            return i;
        }
    }
    return 0; // 如果没有找到字符，则返回0（虽然按理来说应该不会发生）
}

void decrypt(unsigned char *input, int len)
{
    unsigned int num = 0;
    unsigned int tmp;
    unsigned char a;

    for (int i = 0; i < len; i += 4) {
        num = 0;
        a = input[i + 1];
        input[i + 1] = input[i + 2];
        input[i + 2] = a;

        for (int k = 0; k < 4; k++) {
            tmp = findchar(input[i + k]);
            tmp = (tmp << ((3 - k) * 6));
            num |= tmp;
        }

        for (int k = 2; k >= 0; k--) {
            a = *((unsigned char*)&num + k);
            printf("%c", a);
        }
    }
}

void encrypt(unsigned char *input, int len)
{
    unsigned char a;
    unsigned int tmp, num;
    
    for (int i = 0; i < len; i += 3) {
        tmp = 0;
        for (int k = 0; k < 3; k++) {
            num = (input[i + k]);
            tmp += (num << (8 * (2 - k)));
        }
        
        for (int k = 0; k < 4; k++) {
            a = (tmp >> ((3 - k) * 6)) & 0x3F;
            a = table[a];
            printf("%c", a);
        }
    }
    printf("\n");
}

int main()
{
    decrypt(s, 12);
    return 0;
}

dfs.c

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int s[0x401];
unsigned char key[] = "c9m1bRmfY5Wk";
unsigned char input[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef";

// 加密函数
unsigned int enc(unsigned int v7, unsigned int& v4)
{
    unsigned int v2, op;     //我累个op
    for (int k = 0; k < 32; k++) {
        op = ((s[v4] ^ v7) % 5 + 5) % 5;  // 计算操作类型
        if (op == 0) {
            v2 = ((v7 + s[v4]) % 0x400 + 0x400) % 0x400;
            v4 = (v4 + v2) % 0x400;
            v7 = v2;
        }
        else if (op == 1) {
            v2 = ((v7 - s[v4]) % 0x400 + 0x400) % 0x400;
            v4 = (v4 + v2) % 0x400;
            v7 = v2;
        }
        else if (op == 2) {
            v2 = ((v7 ^ s[v4]) % 0x400 + 0x400) % 0x400;
            v4 = (v4 + v2) % 0x400;
            v7 = v2;
        }
        else if (op == 3) {
            v2 = (v7 >> 3) % 0x400;
            v4 = (v4 + v2) % 0x400;
            v7 = v2;
        }
        else if (op == 4) {
            v2 = (v7 << 3) % 0x400;
            v4 = (v4 + v2) % 0x400;
            v7 = v2;
        }
    }
    return v7;
}

// 密文数组
unsigned int cipher[] = { 0x160, 646, 0x2F0, 882, 65, 0, 0x7A, 0, 0, 7, 350, 360 };
unsigned char tab[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_";
int cipher_len = 12;

// 深度优先搜索，递归查找密码
void dfs(int index, unsigned int idx, string flag) //idx就是i
{
    if (index >= cipher_len) {
        // 当找到完整的密码时，打印 flag
        cout << flag << endl;
        return;
    }

    unsigned int v7, v2;
    unsigned int v4 = idx;
    unsigned int save_v4 = v4;  // 保存当前v4值

    for (int k = 0; k <= 53; k++) {
        v4 = save_v4;  // 每次循环都恢复v4
        v7 = tab[k];   // 取tab数组中的一个字符
        v2 = enc(v7, v4);  // 计算加密结果

        // 如果加密结果和当前密文匹配，则继续递归
        if (v2 == cipher[index]) {
            flag += char(v7);  // 将当前字符添加到 flag 中
            dfs(index + 1, v4, flag);  // 递归调用
            flag.pop_back();  // 回溯，删除最后一个字符
        }
    }
}

int main()
{
    // 初始化 s 数组
    for (int i = 0; i < 0x400; i++) {
        s[0x3FF - i] = i;
    }

    // 根据 key 对 s 数组进行异或加密
    for (int i = 0; i < 0x400; i++) {
        s[i] ^= key[i % 12];
    }

    unsigned int v4 = 33;  // 初始化 v4
    string flag = "";      // 用来存储密码的字符串
    dfs(0, v4, flag);      // 从第一个字符开始深度优先搜索

    return 0;
}

欸，太强了（挠屁股.jpg）

eazykey

不会内核，跟着别的师傅的wp复现（

https://lilachit.notion.site/2024-Re-Pwn-WP-by-Lilac-2698b2aad54d420dac920fbdee1fb5d4

找入口，然后找主逻辑

v11

这个函数 sub_180001530 是一个 Windows 驱动程序中的 I/O 请求处理函数，负责处理与 IRP 相关的 I/O 请求。
函数根据 IRP 的不同状态（通过 CurrentLocation 字段来判断）执行不同的操作。
如果 CurrentLocation == 1，表示发生了某种错误，函数会将 IRP 标记为错误状态并完成请求。
如果没有错误，函数会获取设备对象，并将 IRP 传递给驱动程序进行后续处理。

v12

sub_180001FF0 是一个处理电源管理和 I/O 请求的函数。它的主要步骤包括：

确保传入的 a1 和从中提取的指针（v3）都经过对齐检查。
启动一个新的电源 IRP 操作（PoStartNextPowerIrp）。
调用其他辅助函数来处理 IRP（如 sub_180001480）。
将处理后的 IRP 传递给设备驱动程序进行后续操作。

v13

sub_18000C5D0：这是一个处理内存对齐的函数。如果某个对象的地址不是合适的对齐，它会处理并调整。

sub_180001730：这个函数用于处理传入的 IRP，返回与 IRP 相关的某些值或指针。

sub_180001480：这个函数似乎用于处理 IRP，可能是修改 IRP 的状态或执行特定操作。

IofCallDriver：将 IRP 传递给驱动程序进行处理，通常用于向下层驱动发送 I/O 请求。

IoDetachDevice 和 IoDeleteDevice：用于从设备堆栈中分离设备并删除设备对象，通常用于卸载设备。

显然，v11因该是个read,比较可疑，其实感觉这里已经可以根据wp猜测这是个键盘驱动了

一个个点开来看

这里有些奇怪的东西

那么enter过后一般是不是就要检查了

确实，根据字符串提示应该是了

很明显就是一个普通的对比，所以再根据墨水✌的wp,应该就是在键盘上敲对应的按键就行了

可以去这里找按键

https://bbs.kanxue.com/thread-270393.htm

或者问下ai

键盘按键	扫描码 (Hex)	扫描码 (Decimal)
Esc	0x01	1
F1	0x3B	59
F2	0x3C	60
F3	0x3D	61
F4	0x3E	62
F5	0x3F	63
F6	0x40	64
F7	0x41	65
F8	0x42	66
F9	0x43	67
F10	0x44	68
F11	0x57	87
F12	0x58	88
Print Screen	0x137	311
Scroll Lock	0x46	70
Pause/Break	0x145	325
~ (Tilde)	0x29	41
1	0x02	2
2	0x03	3
3	0x04	4
4	0x05	5
5	0x06	6
6	0x07	7
7	0x08	8
8	0x09	9
9	0x0A	10
0	0x0B	11
- (Minus)	0x0C	12
= (Equal)	0x0D	13
Backspace	0x0E	14
Tab	0x0F	15
Q	0x10	16
W	0x11	17
E	0x12	18
R	0x13	19
T	0x14	20
Y	0x15	21
U	0x16	22
I	0x17	23
O	0x18	24
P	0x19	25
[ (Left Bracket)	0x1A	26
] (Right Bracket)	0x1B	27
\ (Backslash)	0x2B	43
Caps Lock	0x3A	58
A	0x1E	30
S	0x1F	31
D	0x20	32
F	0x21	33
G	0x22	34
H	0x23	35
J	0x24	36
K	0x25	37
L	0x26	38
; (Semicolon)	0x27	39
' (Apostrophe)	0x28	40
Enter	0x1C	28
Shift (Left)	0x2A	42
Z	0x2C	44
X	0x2D	45
C	0x2E	46
V	0x2F	47
B	0x30	48
N	0x31	49
M	0x32	50
, (Comma)	0x33	51
. (Period)	0x34	52
/ (Slash)	0x35	53
Shift (Right)	0x36	54
Ctrl (Left)	0x1D	29
Windows (Left)	0xE0 0x5B	91
Alt (Left)	0x38	56
Space	0x39	57
Alt (Right)	0xE0 0x38	56
Windows (Right)	0xE0 0x5C	92
Menu	0xE0 0x5D	93
Ctrl (Right)	0xE0 0x1D	29
Up Arrow	0xE0 0xC8	200
Down Arrow	0xE0 0xD0	208
Left Arrow	0xE0 0xCB	203
Right Arrow	0xE0 0xCD	205
Insert	0xE0 0x52	82
Home	0xE0 0x47	71
Page Up	0xE0 0x49	73
Delete	0xE0 0x53	83
End	0xE0 0x4F	79
Page Down	0xE0 0x51	81
Num Lock	0xE0 0x45	69
/ (Numpad)	0xE0 0xB5	181
*** (Numpad)**	0xE0 0x37	55
- (Numpad)	0xE0 0x4A	74
+ (Numpad)	0xE0 0x4E	78
Enter (Numpad)	0xE0 0x1C	28
1 (Numpad)	0xE0 0x4F	79
2 (Numpad)	0xE0 0x50	80
3 (Numpad)	0xE0 0x51	81
4 (Numpad)	0xE0 0x4B	75
5 (Numpad)	0xE0 0x4C	76
6 (Numpad)	0xE0 0x4D	77
7 (Numpad)	0xE0 0x47	71
8 (Numpad)	0xE0 0x48	72
**9 (Nump		
键盘按键	扫描码 (Hex)	扫描码 (Decimal)
9 (Numpad)	0xE0 0x49	73
0 (Numpad)	0xE0 0x50	80
. (Numpad)	0xE0 0x53	83
Enter (Numpad)	0xE0 0x1C	28
特殊功能键
键盘按键	扫描码 (Hex)	扫描码 (Decimal)
Windows (Left)	0xE0 0x5B	91
Windows (Right)	0xE0 0x5C	92
Menu	0xE0 0x5D	93
Ctrl (Left)	0x1D	29
Ctrl (Right)	0xE0 0x1D	29
Alt (Left)	0x38	56
Alt (Right)	0xE0 0x38	56
Space	0x39	57
Escape	0x01	1

再对应写个脚本就行

keys = [32,42,11,34,4,45,34,42,46,42, 26, 42, 30, 7, 7, 48, 3, 4, 5, 3, 12, 11, 5, 32, 5, 12, 5, 7, 9, 30, 12, 10, 10, 32 , 4, 12, 8, 18, 32, 48, 30, 5, 46, 10, 11, 11, 2, 33, 27, 42]

d = {0x1E: "A", 0x30: "B", 0x2E: "C", 0x20: "D", 0x12: "E", 0x21: "F", 0x22: "G", 0x23: "H", 0x17: "I", 0x24: "J", 0x25: "K", 0x26: "L", 0x32: "M", 0x31: "N", 0x18: "O", 0x19: "P", 0x10: "Q", 0x13: "R", 0x1F: "S", 0x14: "T", 0x16: "U", 0x2F: "V", 0x11: "W", 0x2D: "X", 0x15: "Y", 0x2C: "Z", 0x02: "1", 0x03: "2", 0x04: "3", 0x05: "4", 0x06: "5", 0x07: "6", 0x08: "7", 0x09: "8", 0x0A: "9", 0x0B: "0", 0x2a: "[shift]", 0xc: "-"}

i = 0

while i < len(keys):
    v = keys[i]
    if v in d:
        if i + 1 < len(keys) and keys[i + 1] == 0x2a: # shift
            print(d[v], end = "")
            i += 1
        else:
            print(d[v].lower(), end = "")
    else:
        print(f"[{hex(v)}]", end="")
    i += 1

polar赛后复盘

本来上次打了就不想再打了，但是还是过来看看有什么有意思的题，每次都让人出乎意料

o_0

我以为die没查出来，原来是我眼瞎了

Mac 的运行程序 arm 64位

好难看啊

没运行环境，裂开，静态分析一下

注意，这里0就是一个函数了，就是判断奇数偶数

v30

然后就是分析加密流程

最后的比较

这里学到点新的数组索引方式

v4 = (_DWORD *)std::vector<int>::operator[][abi:ne180100](v25, j);
1. std::vector<int>::operator[]
std::vector<int> 是 C++ STL 中的一个模板类，表示存储 int 类型元素的动态数组。
operator[] 是该类的成员函数，用于访问 vector 中指定索引的元素。
通过 operator[] 可以访问该 vector 中指定位置的元素，v25 可能是一个 std::vector<int> 类型的对象，而 j 是索引。

decipher

经典3.9以上,这玩意失效了，这次一定要配个好的

uncompyle6 dialogue.pyc

pycdc,别忘了放哪里了o.o

F:\re_in_all\pyextra\afe4b-main\pycdc

pycdc your_file_name.pyc > output_file_name.py

看看效果

# Source Generated with Decompyle++
# File: dialogue.pyc (Python 3.10)

import os
import base64
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util.Padding import pad

def generate_key_and_salt(password):
    salt = os.urandom(16)
    key = PBKDF2(password, salt, 32, 1000000, **('dkLen', 'count'))
    return (key, salt)


def encrypt(password, plaintext):
    (key, salt) = generate_key_and_salt(password)
    cipher = AES.new(key, AES.MODE_CBC)
    ciphertext = cipher.encrypt(pad(plaintext.encode('utf-8'), AES.block_size))
    encoded_ciphertext = base64.b64encode(salt + cipher.iv + ciphertext).decode('utf-8')
    return encoded_ciphertext


def encrypt_password_file(password, input_file, output_file):
    with open(input_file, 'r') as f:
        plaintext = f.read()
        None(None, None, None)
# WARNING: Decompyle incomplete

if __name__ == '__main__':
    password = input('Enter encryption password: ')
    input_file = 'records.txt'
    output_file = 'en_records.txt'
    encrypt_password_file(password, input_file, output_file)
    return None

然后要手动改一部分

 key = PBKDF2(password, salt, 32, 1000000, **('dkLen', 'count'))
 变成
  key = PBKDF2(password, salt, dkLen = 32, count = 1000000, )
# 我记得上次看到盐值也是在polar,不过上次是java,乐

ai🔒个解密脚本

import os
import base64
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util.Padding import unpad

def generate_key_and_salt(password, salt):
    # 使用密码和盐生成密钥
    key = PBKDF2(password, salt, 32, 1000000)
    return key

def decrypt(password, encrypted_text):
    # 解码 base64 编码的密文
    encrypted_data = base64.b64decode(encrypted_text)
    
    # 提取盐、iv 和密文部分
    salt = encrypted_data[:16]
    iv = encrypted_data[16:32]
    ciphertext = encrypted_data[32:]
    
    # 使用密码和盐生成密钥
    key = generate_key_and_salt(password, salt)
    
    # 创建 AES 解密器
    cipher = AES.new(key, AES.MODE_CBC, iv)
    
    # 解密密文并去除填充
    decrypted_data = unpad(cipher.decrypt(ciphertext), AES.block_size)
    
    # 将解密后的数据转换为字符串并返回
    return decrypted_data.decode('utf-8')

def decrypt_password_file(password, input_file, output_file):
    with open(input_file, 'r') as f:
        encrypted_text = f.read()
    
    # 解密内容
    plaintext = decrypt(password, encrypted_text)
    
    # 将解密后的内容写入输出文件
    with open(output_file, 'w') as f:
        f.write(plaintext)

if __name__ == '__main__':
    password = input('Enter decryption password: ')
    input_file = 'en_records.txt'
    output_file = 'de.txt'
    decrypt_password_file(password, input_file, output_file)
    print('Decryption completed and saved to', output_file)

额…….