import os
import zipfile
import rarfile
import py7zr
import re
from threading import Timer

# 配置
MAX_DEPTH = 1000  # 防止无限递归
CURRENT_DEPTH = 0
FLAG_PATTERN = r'flag\{.*?\}'
PASSWORDS = ['', 'password', '123456', 'flag']

def extract_archive(file_path, extract_dir, password=None):
    """解压支持的压缩格式"""
    try:
        if file_path.endswith('.zip'):
            with zipfile.ZipFile(file_path, 'r') as z:
                if password:
                    z.extractall(extract_dir, pwd=password.encode())
                else:
                    z.extractall(extract_dir)
            return True
        elif file_path.endswith('.rar'):
            with rarfile.RarFile(file_path, 'r') as r:
                if password:
                    r.extractall(extract_dir, pwd=password)
                else:
                    r.extractall(extract_dir)
            return True
        elif file_path.endswith('.7z'):
            with py7zr.SevenZipFile(file_path, 'r', password=password) as a:
                a.extractall(extract_dir)
            return True
        else:
            print(f"Unsupported format: {file_path}")
            return False
    except Exception as e:
        print(f"Extraction failed: {str(e)}")
        return False

def search_flag(directory):
    """在目录中搜索flag"""
    for root, _, files in os.walk(directory):
        for file in files:
            path = os.path.join(root, file)
            try:
                with open(path, 'rb') as f:
                    content = f.read().decode('utf-8', errors='ignore')
                    if re.search(FLAG_PATTERN, content):
                        match = re.search(FLAG_PATTERN, content)
                        print(f"[+] Flag found: {match.group()} in {path}")
                        os._exit(0)  # 立即退出
            except:
                continue
    return False

def recursive_extract(start_dir, depth=0):
    global CURRENT_DEPTH
    if depth >= MAX_DEPTH:
        print("[-] Max depth reached. Aborting.")
        return

    # 搜索当前目录
    if search_flag(start_dir):
        return

    # 查找压缩文件
    archives = []
    for f in os.listdir(start_dir):
        full_path = os.path.join(start_dir, f)
        if os.path.isfile(full_path) and any(f.endswith(ext) for ext in ['.zip', '.rar', '.7z']):
            archives.append(full_path)

    # 按修改时间排序，优先处理最新文件（可能更接近flag）
    archives.sort(key=lambda x: os.path.getmtime(x), reverse=True)

    for archive in archives:
        print(f"[*] Processing {archive} at depth {depth}")
        extract_dir = os.path.join(start_dir, f"extracted_{depth}")
        os.makedirs(extract_dir, exist_ok=True)

        # 尝试空密码解压
        success = extract_archive(archive, extract_dir)
        if not success:
            # 尝试密码破解
            for pwd in PASSWORDS:
                print(f"[*] Trying password: {pwd}")
                success = extract_archive(archive, extract_dir, pwd)
                if success:
                    break

        if success:
            recursive_extract(extract_dir, depth + 1)
        else:
            print(f"[-] Failed to extract {archive}")

if __name__ == "__main__":
    # 设置超时（例如30分钟）
    def timeout_handler():
        print("[-] Timeout reached. Exiting.")
        os._exit(1)
    
    Timer(1800, timeout_handler).start()  # 1800秒=30分钟
    recursive_extract(os.getcwd())

from Crypto.Util.number import inverse, long_to_bytes

# 分解后的n的素数因子
p = [
    113,
    18251,
    2001511,
    214168842768662180574654641,
    916848439436544911290378588839845528581
]

# 计算n
n = 1
for prime in p:
    n *= prime

# 分解后的c的因子
c_factors = [
    2,
    3,
    39317,
    200443,
    61399747823107048319,
    230983561625122789653422292020602288585417281109
]

# 计算c
c = 1
for factor in c_factors:
    c *= factor

# 确保c < n，否则无法正确解密
assert c < n, "c must be less than n"

# 计算欧拉函数φ(n)
phi = 1
for prime in p:
    phi *= (prime - 1)

# 计算私钥d
e = 65537
d = inverse(e, phi)

# 解密得到明文m
m = pow(c, d, n)

# 转换为字节并输出
flag = long_to_bytes(m)
print("Flag:", flag.decode())