[SWPUCTF 2024 秋季新生赛]泰坦陨落2 WP
原创[SWPUCTF 2024 秋季新生赛]泰坦陨落2 WP
原创
太岁
修改于 2024-10-30 14:55:31
修改于 2024-10-30 14:55:31
1.领取你的飞天克莱伯：
（线性同余生成器）
# LCG参数
a = 1664525
c = 1013904223
m = 2**32 # 妙蛙种子
seed = ......... # 生成伪随机数
def lcg(seed, n):
numbers = []
for _ in range(n):
seed = (a * seed + c) % m
numbers.append(seed)
return numbers # 给你5个伪随机数
random_numbers = lcg(seed, 5)
print(random_numbers)
#[3771924608, 3319331295, 583630258, 2401321321, 611326900]简单分析一下：
我们需要通过输出的5组数据来倒推出seed（伪随机数）
在这里解出seed：
LCG 的生成公式如下：
Xi+1=(a⋅Xi+c)modm
其中：
a是乘数。c是增量。m是模数（这里为 2322^{32}232）。X_i是当前生成的随机数。X_{i+1}是下一个生成的随机数。
如果我们已知 X_i 和 X_{i+1}，可以通过逆运算推导 X_i 的值，进一步还原最初的种子。
使用逆元计算出 X_i 的逆运算公式
由 LCG 公式可以得到：
Xi=(Xi+1−c)⋅a−1modm
其中：
a^{-1}是a在模m下的乘法逆元。X_i是通过X_{i+1}逆向计算得到的前一个数，从而还原出种子。
exp
def recover_seed(x0, x1):
a = 1664525
c = 1013904223
m = 2**32 # 计算a的逆元
a_inv = pow(a, -1, m) # 计算种子
seed = (x0 - c) * a_inv % m
return seed # 假设已知的随机数
x0 = 3771924608
x1 = 3319331295
x2 = 583630258
x3 = 2401321321
x4 = 611326900
seed = recover_seed(x0, x1)
print(seed) # 输出恢复的种子2.去捞FLAG吧
def xor_encrypt_decrypt(data, key):
key_bytes = key.to_bytes((key.bit_length() + 7) // 8, 'big')
key_length = len(key_bytes)
result = bytearray()
for i in range(len(data)):
result.append(data[i] ^ key_bytes[i % key_length])
return bytes(result)
flag = "NSSCTF{........................................}"
flag_bytes = flag.encode('utf-8')
# 使用妙蛙种子进行加密,如果你没有妙蛙种子，请先去克莱伯那里拿妙蛙种子
key = seed
encrypted_bytes = xor_encrypt_decrypt(flag_bytes, key)
# 输出加密后的字节和字符串
print("Encrypted Bytes:", encrypted_bytes)
#Encrypted Bytes: b"n2!&t'\t\x06A\x14\x01\x00\x00\x16\x17EA\x13\x17ET\t\x17EC\x0e\x1e\nR\x12R\x0cNA\x06\rEA\x16\x04R\n\x0f"同样，来简单分析一下：
这段代码实现了一个基于 XOR（异或）操作的加密和解密函数。它的工作原理是使用一个整数作为密钥，将密钥转换为字节后，通过逐字节的异或操作对数据进行加密或解密。
def xor_encrypt_decrypt(data, key):
key_bytes = key.to_bytes((key.bit_length() + 7) // 8, 'big')
key_length = len(key_bytes)
result = bytearray()
for i in range(len(data)):
result.append(data[i] ^ key_bytes[i % key_length])
return bytes(result)- 参数：
- data：待加密或解密的数据，以字节形式传入。
- key：整数密钥。
- 密钥转换：
- key.to_bytes((key.bit_length() + 7) // 8, 'big')：将整数密钥转换为字节数组（key_bytes）。
- (key.bit_length() + 7) // 8：计算密钥所需的字节长度。
- big：使用大端格式进行转换。
- 逐字节 XOR 操作：
- for i in range(len(data))：遍历数据的每个字节。
- result.append(data[i] ^ key_bytes[i % key_length])：将数据的每个字节与密钥的相应字节进行异或操作，得到加密后的字节。
- key_bytes[i % key_length]：密钥的长度可能小于数据长度，所以使用取模运算来重复使用密钥字节，实现循环密钥。
- 返回结果：result 存储了 XOR 操作后的字节，将其转换为 bytes 类型并返回。
- 使用一个密钥 seed（前提是之前通过逆运算已经恢复出来的 LCG 种子）。
- xor_encrypt_decrypt(flag_bytes, key)：调用 XOR 加密函数，将 flag_bytes 使用 key 进行异或加密。
ok了，理论结束，开始实践：
- 使用 xor_encrypt_decrypt(encrypted_bytes, key) 对密文进行解密。
- 函数返回的 decrypted_bytes 是解密后的字节数据。
- 解码并输出结果：
- decrypted_bytes.decode('utf-8')：将解密后的字节转换回字符串格式，以获取原始的 flag。
- print("Decrypted Flag:", decrypted_flag) 输出解密后的 flag
用seed来解flag：exp
def xor_encrypt_decrypt(data, key):
key_bytes = key.to_bytes((key.bit_length() + 7) // 8, 'big')
key_length = len(key_bytes)
result = bytearray()
for i in range(len(data)):
result.append(data[i] ^ key_bytes[i % key_length])
return bytes(result)
encrypted_bytes = b"n2!&t'\t\x06A\x14\x01\x00\x00\x16\x17EA\x13\x17ET\t\x17EC\x0e\x1e\nR\x12R\x0cNA\x06\rEA\x16\x04R\n\x0f"
key = 543257189
decrypted_bytes = xor_encrypt_decrypt(encrypted_bytes, key)
decrypted_flag = decrypted_bytes.decode('utf-8')
print("Decrypted Flag:", decrypted_flag)原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
评论
登录后参与评论
推荐阅读
目录
腾讯云开发者
