week7-re-ISCC

something

先die查壳

用ida打开后，直接进入main函数，看到与pyinstaller有关，利用python反编译一下（需要在同一目录下）

这个题不会啊

冗余的代码

依旧是先查壳

拖进ida

shift+f12看一下 关键字，看到下面的部分，猜测可能是与flag有关，跟进看看

看到爆红的部分，可能是花指令，去除一下，nop掉，按C编译

一个接着一个，本来想数一下的，但是太多了，没数过来，我们把他们全部nop掉就行了

方法一：

重新看一下关键字，依旧是刚才那个地方 跟进一下，看到那个部分的函数，试一下动调

目前没有成功

方法二：

看wp中写的，直接利用idapython一把梭，先把代码放上，再看看逻辑

import struct

def xxtea_encrypt(data, key):
    def mx():
        return (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum_ ^ y) + (key[(p & 3) ^ e] ^ z)))

    n = len(data)
    if n < 2:
        return data
    rounds = 6 + 52 // n
    sum_ = 0
    delta = 0x9e3779b9
    y = 0
    z = data[-1]
    for _ in range(rounds):
        sum_ = (sum_ + delta) & 0xffffffff
        e = (sum_ >> 2) & 3
        for p in range(n):
            y = data[(p + 1) % n]
            z = data[p] = (data[p] + mx()) & 0xffffffff
    return data

def read_key_from_exe(file_path, offset=0x30e20):
    with open(file_path, 'rb') as f:
        f.seek(offset)
        key_bytes = f.read(16)
        if len(key_bytes) != 16:
            raise ValueError("读取 key 失败，长度不足 16 字节")
        return list(struct.unpack('<4I', key_bytes))

def main():
    exe_path = "冗余的代码.exe"  # 替换为实际路径
    v = [33686020, 67174660, 67240450]
    xor_key = [0x0d, 0x0c, 0x0b, 0x0a, 0x11, 0x10, 0x0f, 0x0e, 0x15, 0x14, 0x13, 0x12]
    key = read_key_from_exe(exe_path)

    encrypted = xxtea_encrypt(v.copy(), key)
    encrypted_bytes = b''.join(struct.pack('<I', x) for x in encrypted)
    xor_result = bytes(b ^ xor_key[i] for i, b in enumerate(encrypted_bytes))
    final = struct.unpack('<III', xor_result)

    print("ISCC{", end='')
    for num in final:
        print(f"{num:08x}", end='')  
    print("}")

if __name__ == "__main__":
    main()

这段代码涉及XXTEA，结合xor异或操作，最终生成字符串（也就是flag）

• 从这个文件中读取16字节密钥
• 使用 XXTEA 算法 加密给定的整数数组 v = [33686020, 67174660, 67240450]
• 对加密后的数据再进行 逐字节 XOR 操作
• 将结果转换为十六进制格式，拼接成 ISCC{...} 形式的字符串。

运行后直接得到flag

faze

依旧是先查壳

拖进ida中，直接查看一下关键字

我们发现这个flag是自己输入的，我们可以用动调解决类似题目，我们先跟进这段，进入这段代码

我们在correct这里和incorrect都下一个断点

随便输入flag后我们就直接得到了flag

ISCC{(O[&TR\7@ye@}

SecretGird

依旧是先查壳

拖进ida中

我想调试一下，出现下面的问题

出现和wp中一样的问题

解决好后重新来一遍

我们看到main函数中

调用 checklist1() 判断输入格式是否合格。

• 不合格直接提示“Invalid format”。

如果合格，则调用 checklist2() 评分。

• 如果得分 > 4，显示鼓励信息并显示 flag。
• 否则提示失败。

看一下这两段函数的具体内容

calist中 是数独填写内容

我们看一下printflag函数

里面有密文

提取解密

v2[0] ="S12305C9421FFD093E1002C7C3F0B78907F000C909F00083920000913F001E4800012C7E";
v2[1] ="S123052C813F001E552907FE2F890000409E058813F001E815F000C7D2A4A1489290000FF";
v2[2] ="S123054C7D2A07743D2100821098013F001E7D284A1489290003920005529263EC7F";
v2[3] ="S123056C7D294077D494A78D274813F001E815F000C7D2A4A1559A063E99490000074";
v2[4] ="S123058C480800BC815F001ED205556512955567D0A48967D49FE707D2940501D2900317";
v2[5] ="S12305AC7D295052F890000409E058813F001E815F000C7D2A4A14892900007D2A0A7476";
v2[6] ="S12305CC3D2100281098013F001E7D284A148929000039200055292067D297043F";
v2[7] ="S12305EC7D494A787D287D4813F001E815F000C7D2A4A1455A063E994900000D2";
v2[8] ="S123060C813F001E815F000C7D2A4A1489902003D210028149018813F001E7D2A4A145A";
v2[9] ="S123062C8949000813F001E80FF0003D274A147D0A527855A063E9949000813F001E0EA1";
v2[10] ="S123064C329900013F001E4809DFED0831F0083929001F394000040";
v2[11] ="S11B066C99490006000000397F00383EBFFFC7D615B784E80002060";

这里就直接使用wp中的脚本了····

from capstone import *
import re

# Motorola S-record数据
s_records = [
    "S123050C9421FFD093E1002C7C3F0B78907F000C909F000839200000913F001E4800012C7E",
    "S123052C813F001E552907FE2F890000409E0058813F001E815F000C7D2A4A1489290000FF",
    "S123054C7D2A07743D20100281090018813F001E7D284A1489290000392900025529063EC7",
    "S123056C7D2907747D494A787D280774813F001E815F00087D2A4A14550A063E9949000074",
    "S123058C480000BC815F001E3D205555612955567D0A48967D49FE707D2940501D29000317",
    "S12305AC7D2950502F890000409E0058813F001E815F000C7D2A4A14892900007D2A077476",
    "S12305CC3D20100281090018813F001E7D284A1489290000392900055529063E7D2907743F",
    "S12305EC7D494A787D280774813F001E815F00087D2A4A14550A063E99490000480000408D",
    "S123060C813F001E815F000C7D2A4A14890900003D20100281490018813F001E7D2A4A145A",
    "S123062C89490000813F001E80FF00087D274A147D0A5278554A063E99490000813F001EA1",
    "S123064C39290001913F001E813F001E2F89001E409DFED0813F00083929001F3940000040",
    "S11B066C9949000060000000397F003083EBFFFC7D615B784E80002060"
]


def parse_s_record(srec):
    """解析Motorola S-record，返回地址和字节数据"""
    if not srec.startswith('S'):
        return None, None

    record_type = srec[1]
    length = int(srec[2:4], 16) - 3  # 减去地址和校验和占用的字节

    if record_type == '1':
        # S1记录：16位地址
        address = int(srec[4:8], 16)
        data = srec[8:-2]
    elif record_type == '2':
        # S2记录：24位地址
        address = int(srec[4:10], 16)
        data = srec[10:-2]
    elif record_type == '3':
        # S3记录：32位地址
        address = int(srec[4:12], 16)
        data = srec[12:-2]
    else:
        return None, None

    # 将十六进制字符串转换为字节数组
    byte_data = bytes.fromhex(data)
    return address, byte_data


def disassemble_ppc(address, code):
    """使用Capstone反汇编PowerPC代码"""
    md = Cs(CS_ARCH_PPC, CS_MODE_32 + CS_MODE_BIG_ENDIAN)
    md.detail = True

    assembly = []
    for insn in md.disasm(code, address):
        assembly.append(f"0x{insn.address:08X}:\t{insn.mnemonic}\t{insn.op_str}")

    return assembly


def main():
    # 收集所有代码段
    code_segments = []
    for srec in s_records:
        addr, data = parse_s_record(srec)
        if addr is not None and data:
            code_segments.append((addr, data))

    # 按地址排序
    code_segments.sort()

    # 合并连续的代码段
    merged_code = bytearray()
    current_addr = None
    last_addr = None
    last_len = 0

    for addr, data in code_segments:
        if last_addr is None:
            # 第一个段
            merged_code.extend(data)
            current_addr = addr
            last_addr = addr + len(data)
        else:
            if addr == last_addr:
                # 连续段
                merged_code.extend(data)
                last_addr += len(data)
            else:
                # 不连续段，先反汇编已合并的
                if merged_code:
                    print(f"\n=== 段地址: 0x{current_addr:08X}-0x{last_addr:08X} ===")
                    asm = disassemble_ppc(current_addr, merged_code)
                    for line in asm:
                        print(line)

                # 开始新段
                merged_code = bytearray(data)
                current_addr = addr
                last_addr = addr + len(data)

    # 反汇编最后一段
    if merged_code:
        print(f"\n=== 段地址: 0x{current_addr:08X}-0x{last_addr:08X} ===")
        asm = disassemble_ppc(current_addr, merged_code)
        for line in asm:
            print(line)


if __name__ == "__main__":
    main()

运行后看到汇编代码

D:\PyCharmProjects\aaa\.venv\Scripts\python.exe "C:\Users\Lenovo\Documents\WeChat Files\wxid_ummbals4orzj22\FileStorage\File\2025-05\123.py" 

=== 段地址: 0x0000050C-0x00000684 ===
0x0000050C:	stwu	r1, -0x30(r1)
0x00000510:	stw	r31, 0x2c(r1)
0x00000514:	mr	r31, r1
0x00000518:	stw	r3, 0xc(r31)
0x0000051C:	stw	r4, 8(r31)
0x00000520:	li	r9, 0
0x00000524:	stw	r9, 0x1e(r31)
0x00000528:	b	0x654
0x0000052C:	lwz	r9, 0x1e(r31)
0x00000530:	clrlwi	r9, r9, 0x1f
0x00000534:	cmpwi	cr7, r9, 0
0x00000538:	bf	4*cr7+eq, 0x590
0x0000053C:	lwz	r9, 0x1e(r31)
0x00000540:	lwz	r10, 0xc(r31)
0x00000544:	add	r9, r10, r9
0x00000548:	lbz	r9, 0(r9)
0x0000054C:	extsb	r10, r9
0x00000550:	lis	r9, 0x1002
0x00000554:	lwz	r8, 0x18(r9)
0x00000558:	lwz	r9, 0x1e(r31)
0x0000055C:	add	r9, r8, r9
0x00000560:	lbz	r9, 0(r9)
0x00000564:	addi	r9, r9, 2
0x00000568:	clrlwi	r9, r9, 0x18
0x0000056C:	extsb	r9, r9
0x00000570:	xor	r9, r10, r9
0x00000574:	extsb	r8, r9
0x00000578:	lwz	r9, 0x1e(r31)
0x0000057C:	lwz	r10, 8(r31)
0x00000580:	add	r9, r10, r9
0x00000584:	clrlwi	r10, r8, 0x18
0x00000588:	stb	r10, 0(r9)
0x0000058C:	b	0x648
0x00000590:	lwz	r10, 0x1e(r31)
0x00000594:	lis	r9, 0x5555
0x00000598:	ori	r9, r9, 0x5556
0x0000059C:	mulhw	r8, r10, r9
0x000005A0:	srawi	r9, r10, 0x1f
0x000005A4:	sub	r9, r8, r9
0x000005A8:	mulli	r9, r9, 3
0x000005AC:	sub	r9, r10, r9
0x000005B0:	cmpwi	cr7, r9, 0
0x000005B4:	bf	4*cr7+eq, 0x60c
0x000005B8:	lwz	r9, 0x1e(r31)
0x000005BC:	lwz	r10, 0xc(r31)
0x000005C0:	add	r9, r10, r9
0x000005C4:	lbz	r9, 0(r9)
0x000005C8:	extsb	r10, r9
0x000005CC:	lis	r9, 0x1002
0x000005D0:	lwz	r8, 0x18(r9)
0x000005D4:	lwz	r9, 0x1e(r31)
0x000005D8:	add	r9, r8, r9
0x000005DC:	lbz	r9, 0(r9)
0x000005E0:	addi	r9, r9, 5
0x000005E4:	clrlwi	r9, r9, 0x18
0x000005E8:	extsb	r9, r9
0x000005EC:	xor	r9, r10, r9
0x000005F0:	extsb	r8, r9
0x000005F4:	lwz	r9, 0x1e(r31)
0x000005F8:	lwz	r10, 8(r31)
0x000005FC:	add	r9, r10, r9
0x00000600:	clrlwi	r10, r8, 0x18
0x00000604:	stb	r10, 0(r9)
0x00000608:	b	0x648
0x0000060C:	lwz	r9, 0x1e(r31)
0x00000610:	lwz	r10, 0xc(r31)
0x00000614:	add	r9, r10, r9
0x00000618:	lbz	r8, 0(r9)
0x0000061C:	lis	r9, 0x1002
0x00000620:	lwz	r10, 0x18(r9)
0x00000624:	lwz	r9, 0x1e(r31)
0x00000628:	add	r9, r10, r9
0x0000062C:	lbz	r10, 0(r9)
0x00000630:	lwz	r9, 0x1e(r31)
0x00000634:	lwz	r7, 8(r31)
0x00000638:	add	r9, r7, r9
0x0000063C:	xor	r10, r8, r10
0x00000640:	clrlwi	r10, r10, 0x18
0x00000644:	stb	r10, 0(r9)
0x00000648:	lwz	r9, 0x1e(r31)
0x0000064C:	addi	r9, r9, 1
0x00000650:	stw	r9, 0x1e(r31)
0x00000654:	lwz	r9, 0x1e(r31)
0x00000658:	cmpwi	cr7, r9, 0x1e
0x0000065C:	bf	4*cr7+gt, 0x52c
0x00000660:	lwz	r9, 8(r31)
0x00000664:	addi	r9, r9, 0x1f
0x00000668:	li	r10, 0
0x0000066C:	stb	r10, 0(r9)
0x00000670:	nop	
0x00000674:	addi	r11, r31, 0x30
0x00000678:	lwz	r31, -4(r11)
0x0000067C:	mr	r1, r11
0x00000680:	blr	

进程已结束，退出代码为 0

依照这个逻辑再写一个python脚本

def encrypt(input_data, output):
    key = "ISCC{s_ale_ru_upatu_prrlaullre_}"#密钥
    for i in range(30):
        if (i & 1) == 0:
            output[i] = input_data[i] ^ (ord(key[i]) + 2)
        elif i % 3 == 0:
            output[i] = input_data[i] ^ (ord(key[i]) + 5)
        else:
            output[i] = input_data[i] ^ ord(key[i])
    #output.append(0)  # 添加末尾的 null 终止符（但 Python 字符串不需要）

def main():
    v = [45, 117, 43, 112, 10, 0, 66, 19, 88, 33, 23, 66, 83, 48, 61, 67, 94, 34, 47, 60, 56, 69, 94, 57, 55, 45, 8,
         56, 52, 17]#密文
    t = [0] * 30  #
    encrypt(v, t)
    # 转换为字符并打印
    decrypted_str = ''.join([chr(c) for c in t])
    print(decrypted_str)

if __name__ == "__main__":
    main()

运行出结果，加上ISCC{}

就是flag了

greeting

先查壳

找一下main函数

跟进v5，看到有爆红的部分，去花，别忘了按C编译一下

类似如上

重新看一下main函数，还有爆红的部分，那就继续上面的操作

操作完成后，再看一下main函数

找到 加密前的明文，对应的密文就在内存中被读取并解密成 xmmword_14001B390

找到使这段代码生成 xmmword_14001B390 的 v30[i]

那我们就跟进这个函数

看到密文

def ror8(val, shift):
    """ 8-bit 循环右移 """
    return ((val >> shift) | (val << (8 - shift))) & 0xFF

def decrypt(encrypted_data):
    decrypted = bytearray()
    for i in range(16):
        # 1. 计算位移量 (i - 5*(i//5)) % 8
        shift = (i - 5 * (i // 5)) % 8
        # 2. 循环右移 (还原ROL)
        rotated = ror8(encrypted_data[i], shift)
        # 3. XOR (i + 90) 解密
        decrypted_byte = rotated ^ (i + 90)
        decrypted.append(decrypted_byte)
    return decrypted
encrypted_si128 = bytes([
    0x13,0x10,0x7C,0xF0,0x52,0x26,0x86,0x24,0xD8,0xB2,0x00,0x04,0x40,0xB1,0x40,0x14
])
# 解密
decrypted_data = decrypt(encrypted_si128)

# 输出结果
print("解密结果（Hex）:", decrypted_data.hex())
print("解密结果（ASCII）:", decrypted_data.decode('latin-1'))

当然，也可以转成hex后面用赛博厨子也可以

def ror8(val, shift):
    """8-bit 循环右移"""
    return ((val >> shift) | (val << (8 - shift))) & 0xFF

def decrypt(encrypted_data):
    decrypted = bytearray()
    for i in range(16):
        # 1. 计算位移量 (i - 5*(i//5)) % 8
        shift = (i - 5 * (i // 5)) % 8
        # 2. 循环右移 (还原ROL)
        rotated = ror8(encrypted_data[i], shift)
        # 3. XOR (i + 90) 解密
        decrypted_byte = rotated ^ (i + 90)
        decrypted.append(decrypted_byte)
    return decrypted

encrypted_si128 = bytes([
    0x13, 0x10, 0x7C, 0xF0, 0x52, 0x26, 0x86, 0x24,
    0xD8, 0xB2, 0x00, 0x04, 0x40, 0xB1, 0x40, 0x14
])

# 解密
decrypted_data = decrypt(encrypted_si128)

# 仅输出十六进制
print("解密结果（Hex）:", decrypted_data.hex())

再看一下上面的代码的逻辑

si128是目标明文

有趣的小游戏

CrackMe

方法一：

先查壳

看一下关键函数

跟进黄色部分，进去之后tap，修复一下函数表

进去nop掉

去完以后，提取数据

上面看到密钥是SecretKey

from Crypto.Cipher import ARC4

# 1. 硬编码的44字节密文
encrypted_data = bytes([
    0x1C, 0xB8, 0x2E, 0x47, 0xDD, 0x72, 0x1C, 0xA2, 0xDE, 0x13,
    0x06, 0x46, 0x9C, 0xF0, 0x27, 0x81, 0xCC, 0xE6, 0xC9, 0xEE,
    0x2A, 0x9A, 0x0A, 0x28, 0x4A, 0x6B, 0xB9, 0xE8, 0xBF, 0x24,
    0xE3, 0x3F, 0xC7, 0x15, 0x67, 0x17, 0xDB, 0x91, 0xF3, 0xFE,
    0x35, 0x74
])

# 2. RC4解密（密钥="SecretKey"）
def rc4_decrypt(data):
    cipher = ARC4.new(b"SecretKey")
    return cipher.decrypt(data)

rc4_decrypted = rc4_decrypt(encrypted_data)
print(f"RC4 Decrypted: {rc4_decrypted.hex()}")

# 3. 凯撒解密（位移3，仅处理字母）
def caesar_decrypt(data):
    result = []
    for byte in data:
        c = chr(byte)
        if 'A' <= c <= 'Z':
            base = ord('A')
            decrypted = base + (ord(c) - base - 3) % 26  # 反向位移3
            result.append(decrypted)
        elif 'a' <= c <= 'z':
            base = ord('a')
            decrypted = base + (ord(c) - base - 3) % 26
            result.append(decrypted)
        else:
            result.append(byte)  # 非字母直接保留
    return bytes(result)

caesar_decrypted = caesar_decrypt(rc4_decrypted)
print(f"Caesar Decrypted: {caesar_decrypted.hex()}")

# 4. XOR解密（假设HIWORD(a1)=0x41）
def xor_decrypt(data, key=0x41):
    return bytes(b ^ key for b in data)

xor_decrypted = xor_decrypt(caesar_decrypted)
print(f"XOR Decrypted (key=0x41): {xor_decrypted}")

# 尝试直接解码（可能是Flag）
try:
    flag = xor_decrypted.decode('utf-8')
    flag = flag.replace("A", "")
    print(f"Final Flag: {flag}")

except UnicodeDecodeError:
    print("Failed to decode as UTF-8. Try other XOR keys or check steps.")

ISCC{zp#6iNju}US^kTB}

方法二：

idapython脚本一把梭

from ida_bytes import *
printable="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&'()*+,-./:;<=>?@[\]^_`{|}~"
table=[0x0074, 0x0073, 0x0076, 0x0075, 0x0078, 0x0077, 0x007A, 0x0079, 0x0062, 0x0061, 0x0020, 0x0023, 0x0022, 0x0025, 0x0024, 0x0027, 0x0026, 0x0029, 0x0028, 0x002B,
       0x002A, 0x002D, 0x002C, 0x002F, 0x002E, 0x0031, 0x0030, 0x0033, 0x0032, 0x0035, 0x0034, 0x0037, 0x0036, 0x0039, 0x0038, 0x003B, 0x0000, 0x0003, 0x0002, 0x0005,
       0x0004, 0x0007, 0x0006, 0x0009, 0x0008, 0x000B, 0x000A, 0x000D, 0x000C, 0x000F, 0x000E, 0x0011, 0x0010, 0x0013, 0x0012, 0x0015, 0x0014, 0x0017, 0x0016, 0x0019,
       0x0018, 0x001B, 0x0060, 0x0065, 0x0068, 0x0067, 0x006A, 0x0069, 0x006C, 0x006B, 0x006E, 0x006D, 0x0070, 0x006F, 0x0072, 0x0071, 0x007B, 0x0063, 0x007D, 0x007C,
       0x007F,0x007E, 0x0001, 0x001A, 0x001D, 0x001C, 0x001F, 0x001E, 0x0021, 0x003A, 0x003D, 0x003C, 0x003F]

enc=list(get_bytes(0x0140010010,42))
get=[0x67, 0xB8, 0x4F, 0x47, 0xAC, 0x72, 0x6D, 0xA2, 0x97, 0x13,
  0x4E, 0x46, 0xDE, 0xF0, 0x31, 0x81, 0xC5, 0xE6, 0x92, 0xEE,
  0x56, 0x9A, 0x52, 0x28, 0x0D, 0x6B, 0xF6, 0xE8, 0xD8, 0x24,
  0x82, 0x3F, 0xAB, 0x15, 0x3E, 0x17, 0xBD, 0x91, 0x83, 0xFE,
  0x7A, 0x74, 0x64, 0x4B, 0x1B, 0xAB, 0xE0, 0xB6]
for i in range(len(enc)):
    enc[i]^=get[i]^0x73
for i in range(0,len(enc),2):
    print(printable[table.index(enc[i])],end="")

运行得到flag

我们看一下逻辑

解密混淆数据，使用xor异或和查表替换还原原始数据

1. 读取加密数据
2. 用get数组和0x73进行xor解密
3. 每两个字节取第1字节
4. 用printable映射到最终字符，输出结果

uglyCpp

先查壳

直接看一下main函数，看一下

看到有一段奇怪的字符，可能是密文，也就是黄色部分，跟进看一下

看到密文

提取一下其中的数据

v12[0] = 1203532546;     // 0x47C2B102
v12[1] = -1807746716;    // 0x93E3B964
v12[2] = -2001187227;    //x88A0B565  
v12[3] = -339581758;     // 0xECB9E4C2
v12[4] = 1226083970;     // 0x4913C282
v12[5] = 856099254;      // 0x3307F0B6
v12[6] = 1418123825;     // 0x547F3031
v12[7] = -441936971;     // 0xE5C3B4B5
v12[8] = 662953528;      // 0x2784B338

写解密脚本

v = [1203532546,-1807746716,-2001187227,-339581758,1226083970,856099254,1418123825,-441936971,662953528]#密文
v = [i&0xffffffff for i in v]  //转换为无符号数
xor = [0x3ED6325B, 0xD709BF17, 0xE3F27E18, 0xA0870791, 0x0146D6F9, 0x7C6140FF, 0x10B69406, 0x94DDE0F6, 0x40B2BB6C]
for i in range(len(v)):
    v[i] ^= xor[i]
flag = "".join([i.to_bytes(length=4, byteorder="little").decode() for i in v])
print(flag)
c_table = "5p6h7q8d9risbtjuevkwaxlyfzm0c1n2g3o4"
table = "abcdefghijklmnopqrstuvwxyz0123456789"
for i in table:
    print(flag[c_table.index(i)], end="")

看一下脚本的逻辑

ISCC{7TyJERf0u1AF0kcKXHIONDsqegYjs6}

xor运算和查表替换，还原出最终的flag字符串