xor

打开真就是一个非常简单的xor

1
2
3
4
5
6
enc = b"t~suiFz{aM{aMsMwsakM`wdw`awo"
flag =""
for i in range(len(enc)):
    flag += chr((enc[i]) ^ 0x12)
print(flag)
#flag{This_is_a_easy_reverse}

EZRC4

看题目也知道。rc4解密

打开找到key 和 字符串 用在线工具解密就好了。

image-20231025211255890

Tea_apk

XXtea加密还有base64

第一次遇到：它居然有key

image-20231025215426513

在线解密。

ezbroke

用die查看，啥都看不出来。我们用010看看。

image-20231025215751984

这里的PE文件的DOS头被修改了。我们改回去。

image-20231025220006877

用IDA查看，发现是upx壳。我们脱去看看。

image-20231025220027014

报错：

image-20231025220113050

我们重新用010去看。按照经验就是UPX的特征被修改了。

果然：

image-20231025220451858

我们将它该回去：UPX！

得把所有的TUT都改成UPX

image-20231025221723835

然后再来用UPX脱壳。

我用upx -d 就拖掉了。

image-20231025221818165

用IDA pro 打开：

image-20231025221909286

然后就是一个vm的题【第一次遇到还不算会】

但是这个很简单，就只有一个xor

1
2
3
4
5
6
7
8
9
c=''
x=[0x51, 0x44, 0x54, 0x43, 0x51, 0x6C, 0x4E, 0x27, 0x62, 0x37, 0x64, 0x62,
0x74, 0x74, 0x72, 0x64, 0x64, 0x71, 0x62, 0x26, 0x26, 0x6E, 0x37, 0x75,
0x65, 0x27, 0x7C, 0x24, 0x37, 0x7A, 0x6E, 0x37, 0x67, 0x65, 0x27, 0x63,
0x24, 0x74, 0x63, 0x26, 0x27, 0x79, 0x36, 0x36, 0x36, 0x6A]
for i in range(len(x)):
	c+=chr(x[i]^0x17)
print(c)
#FSCTF{Y0u successfu11y br0k3 my pr0t3ct10n!!!}

signin

首先是一个upx的壳

用工具脱掉后。用IDA7.7打开：

image-20231030173507041

发现是循环遍历每一个字符，然后比较然后替换。

FSCTF{it_is_really_obvious_to_find}

MINE SWEEPER

打开就是flag

FSCTF{We1C0m3 t0 rev w0r1d!!!}

ez_pycxor

在线pyc解密：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
flag = ''
key = 'FUTURESTARS'
ciphertxt = [168, 169, 185, 170, 160, 157, 197, 132, 226, 134, 134, 145, 255,
242, 130, 139, 234, 140, 180, 229, 179, 246, 243, 181, 183, 182, 249, 163, 254,
189, 246, 166]
for i in range(len(ciphertxt)):
    if i % 2 == 0:
        ciphertxt[i] ^= ord(key[i % 11])
    if i % 2 == 1:
        ciphertxt[i] ^= ord(key[i % 11])
for i in range(len(ciphertxt)):
    ciphertxt[i] = (ciphertxt[i] - i) ^ 168
    flag += chr(ciphertxt[i])
print(flag)
#FSCTF{8a3ccd61ab7ff9e87acb9c9d1}

ezcode

这个题是一个python字节码的题。遇到这种题，我只能靠Ai。首先通过Ai来分析，因为之前遇到过Ai分析有些许错误的，所以我就大概的看python字节码和Ai帮我写的python代码。

首先：如下是Ai帮我分析出来的。

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# func1
def func1(key, message):
    s_box = func2(key)
    crypt = str(func3(message, s_box))
    return crypt

# func2
def func2(key):
    s_box = list(range(256))
    j = 0
    for i in range(256):
        j = (j + s_box[i] + ord(key[i % len(key)]) % 256) % 256
        s_box[i], s_box[j] = s_box[j], s_box[i]
    return s_box

# func3
def func3(plain, box):
    res = []
    y = 'FSCTF'
    i = j = 0
    for s in plain:
        i = (i + 1) % 256
        j = (j + box[i]) % 256
        box[i], box[j] = box[j], box[i]
        t = (box[i] + box[j]) % 256
        k = box[t]
        res.append(chr(ord(s) ^ k))
    cipher = ''.join(res)
    return cipher

# encode
def encode(inputs):
    s = 'vwxrstuopq34567ABCDEFGHIJyz012PQRSTKLMNOZabcdUVWXYefghijklmn89+/'
    bin_str = []
    for i in inputs:
        x = format(ord(bin(ord(i)), '08b').replace('0b', ''))
        bin_str.append(x)
    
    outputs = ''
    nums = 0

    while bin_str:
        temp_list = bin_str.pop(0)
        temp_str = ''.join(temp_list)
        temp_str_list = [temp_str[i:i+6] for i in range(0, len(temp_str), 6)]

        for i in range(len(temp_str_list)):
            temp_list = [int(c) for c in temp_str_list[i]]
            nums = (len(temp_list) * 6) % 3
            if len(temp_list) * 6 < 24:
                while len(temp_list) * 6 < 24:
                    temp_list.append(0)
                nums = 0

            temp_str_list[i] = str(int(''.join([str(c) for c in temp_list]), 2))

        outputs += ''.join(temp_str_list)

    while nums:
        outputs += '='
        nums -= 1

    return outputs

# Test encode function
message = "Hello, World!"
encoded_message = encode(message)
print("Encoded message:", encoded_message)

# Test func1 function
key = "SecretKey"
encrypted_message = func1(key, message)
print("Encrypted message:", encrypted_message)

这里Ai就分析得有点点错误，我们将它改正：

看到fun 123 ，大概知道是一个rc4的加密。但是是一个魔改后的rc4。

我们来看看正儿八经的Rc4的加密是什么样子：

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
def rc4(key, data):
    S = list(range(256))
    j = 0

    # 初始化S盒
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]

    # 生成密钥流
    key_stream = []
    i = 0
    j = 0
    for byte in data:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        k = S[(S[i] + S[j]) % 256]
        key_stream.append(k)

    # 加密数据
    encrypted_data = []
    for byte, k in zip(data, key_stream):
        encrypted_data.append(byte ^ k)

    return bytes(encrypted_data)

# 使用示例
if __name__ == '__main__':
    key = b'YourSecretKey'  # 16字节的密钥
    data = b'Hello, World!'  # 要加密的数据

    encrypted_data = rc4(key, data)
    print("加密后的数据:", encrypted_data)

    # 解密数据（RC4是自解密的，所以使用相同的密钥再次加密会得到原始数据）
    decrypted_data = rc4(key, encrypted_data)
    print("解密后的数据:", decrypted_data.decode('utf-8'))

image-20231030190105988

最后发现就是多了一个xor。

我们抄上面的代码然后重新写一份加密的数据。然后就解密了

我最后再网上照了一个解密Rc4的脚本，然后修改了一下：

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
def rc4_decrypt(key, ciphertext):
    S = list(range(256))
    j = 0
    key = [ord(char) for char in key]

    # Key-scheduling algorithm
    for i in range(256):
        j = (j + S[i] + key[i % len(key)]) % 256
        S[i], S[j] = S[j], S[i]

    plaintext = bytearray()

    # Pseudo-random generation algorithm
    i = 0
    j = 0
    for char in ciphertext:
        y = 'FSCTF'
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        keystream_byte = S[(S[i] + S[j]) % 256]
        plaintext_byte = ord(char) ^ keystream_byte ^ ord(y[i % len(y)])
        plaintext.append(plaintext_byte)

    return plaintext

# 用你的密钥和密文替换下面的值
key = "XFFTnT"
ciphertext = "=.#MØQïòtÂЭv|·"

plaintext = rc4_decrypt(key, ciphertext)
print("Decrypted Text:", plaintext.decode('utf-8'))
#Decrypted Text: FSCTF{G00d_j0b!!!}