kept_lines_count = 0
removed_lines_count = 0

with open('Data.txt', 'r', encoding='utf-8') as infile, open('Data_new.txt', 'w', encoding='utf-8') as outfile:
    
    for line in infile:
        stripped_line = line.strip()

        if not stripped_line:
            removed_lines_count += 1
            continue

        header_length = 24 # RTP头部的12字节
        is_filler_payload = False
        if len(stripped_line) > header_length:
            payload = stripped_line[header_length:]
            if payload and all(char == 'f' for char in payload):
                is_filler_payload = True

        if is_filler_payload:
            removed_lines_count += 1
            continue

        outfile.write(line)
        kept_lines_count += 1

import wave
import struct
import os
from collections import defaultdict

# --- G.711 μ-law to 16-bit Linear PCM Decoder ---
# 这是一个标准的查找表，用于将8位的μ-law字节解码为16位的线性采样值
_ULAW_DECODE_TABLE = [
    -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
    -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
    -15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
    -11900, -11388, -10876, -10364,  -9852,  -9340,  -8828,  -8316,
    -7932,  -7676,  -7420,  -7164,  -6908,  -6652,  -6396,  -6140,
    -5884,  -5628,  -5372,  -5116,  -4860,  -4604,  -4348,  -4092,
    -3900,  -3772,  -3644,  -3516,  -3388,  -3260,  -3132,  -3004,
    -2876,  -2748,  -2620,  -2492,  -2364,  -2236,  -2108,  -1980,
    -1884,  -1820,  -1756,  -1692,  -1628,  -1564,  -1500,  -1436,
    -1372,  -1308,  -1244,  -1180,  -1116,  -1052,   -988,   -924,
    -876,   -844,   -812,   -780,   -748,   -716,   -684,   -652,
    -620,   -588,   -556,   -524,   -492,   -460,   -428,   -396,
    -372,   -356,   -340,   -324,   -308,   -292,   -276,   -260,
    -244,   -228,   -212,   -196,   -180,   -164,   -148,   -132,
    -120,   -112,   -104,    -96,    -88,    -80,    -72,    -64,
    -56,    -48,    -40,    -32,    -24,    -16,     -8,      0,
    32124,  31100,  30076,  29052,  28028,  27004,  25980,  24956,
    23932,  22908,  21884,  20860,  19836,  18812,  17788,  16764,
    15996,  15484,  14972,  14460,  13948,  13436,  12924,  12412,
    11900,  11388,  10876,  10364,   9852,   9340,   8828,   8316,
    7932,   7676,   7420,   7164,   6908,   6652,   6396,   6140,
    5884,   5628,   5372,   5116,   4860,   4604,   4348,   4092,
    3900,   3772,   3644,   3516,   3388,   3260,   3132,   3004,
    2876,   2748,   2620,   2492,   2364,   2236,   2108,   1980,
    1884,   1820,   1756,   1692,   1628,   1564,   1500,   1436,
    1372,   1308,   1244,   1180,   1116,   1052,    988,    924,
    876,    844,    812,    780,    748,    716,    684,    652,
    620,    588,    556,    524,    492,    460,    428,    396,
    372,    356,    340,    324,    308,    292,    276,    260,
    244,    228,    212,    196,    180,    164,    148,    132,
    120,    112,    104,     96,     88,     80,     72,     64,
    -56,    -48,    -40,    -32,    -24,    -16,     -8,      0
]

def decode_ulaw_to_pcm16(ulaw_data):
    """将一整段 G.711 u-law 字节数据解码为 16-bit 线性 PCM 字节数据"""
    pcm_frames = []
    for ulaw_byte in ulaw_data:
        # 从查找表中获取对应的16位PCM值
        pcm_sample = _ULAW_DECODE_TABLE[ulaw_byte]
        # 将16位整数打包成2个字节（小端序）
        pcm_frames.append(struct.pack('<h', pcm_sample))
    return b''.join(pcm_frames)

def amplify_and_clip_pcm16(pcm_data, factor):
    """
    放大16位PCM数据的音量，并进行削波处理。
    :param pcm_data: 16位PCM字节数据
    :param factor: 放大系数 (例如 2.0 表示放大2倍)
    :return: 放大后的16位PCM字节数据
    """
    # 将字节数据解包成16位整数列表
    samples = struct.unpack(f'<{len(pcm_data) // 2}h', pcm_data)
    
    amplified_samples = []
    for sample in samples:
        amplified_sample = int(sample * factor)
        # 削波处理: 确保值在16位有符号整数范围内
        if amplified_sample > 32767:
            amplified_sample = 32767
        elif amplified_sample < -32768:
            amplified_sample = -32768
        amplified_samples.append(amplified_sample)
        
    # 将处理后的整数列表打包回字节
    return struct.pack(f'<{len(amplified_samples)}h', *amplified_samples)

def write_wav(filename, pcm_data, channels, sampwidth, framerate):
    """一个辅助函数，用于将PCM数据写入WAV文件"""
    try:
        with wave.open(filename, "wb") as wav_file:
            wav_file.setnchannels(channels)
            wav_file.setsampwidth(sampwidth)
            wav_file.setframerate(framerate)
            wav_file.writeframes(pcm_data)
    except Exception as e:
        print(f"写入文件 {filename} 时出错: {e}")

def main():
    input_filename = "Data_new.txt"
    output_dir = "output"
    combined_filename = "combined_audio.wav"
    amplification_factor = 50.0  # 音量放大系数
    
    # WAV文件标准参数
    CHANNELS = 1
    SAMPWIDTH = 2  # 16-bit -> 2 bytes
    FRAMERATE = 8000

    # --- 准备工作 ---
    # 创建输出目录
    os.makedirs(output_dir, exist_ok=True)

    with open(input_filename, "r") as f:
        lines = [line.strip() for line in f if line.strip()]

    # --- 步骤 1: 根据SSRC对RTP包进行分组 ---
    streams = defaultdict(list)
    stream_order = []

    for line in lines:
        if len(line) < 24: continue
        ssrc = line[16:24]
        payload_hex = line[24:]
        if not payload_hex: continue
        
        if ssrc not in streams:
            stream_order.append(ssrc)
        streams[ssrc].append(bytes.fromhex(payload_hex))

    if not streams:
        print("未在文件中找到有效的RTP数据包。")
        return

    print(f"处理完成，共找到 {len(stream_order)} 个不同的音频流。")
    print("SSRC 出现顺序:", stream_order)

    # --- 步骤 2: 逐个处理流，导出片段并准备合并 ---
    final_pcm_data_list = []
    total_samples_processed = 0

    for ssrc in stream_order:
        # 拼接属于同一个流的所有payload
        raw_ulaw_data = b''.join(streams[ssrc])
        if not raw_ulaw_data:
            print(f"SSRC {ssrc} 没有有效的音频数据，已跳过。")
            continue

        # 解码为PCM
        pcm_data = decode_ulaw_to_pcm16(raw_ulaw_data)
        
        # 放大音量
        amplified_pcm_data = amplify_and_clip_pcm16(pcm_data, amplification_factor)

        # 计算片段的开始时间
        start_time_seconds = total_samples_processed / FRAMERATE
        
        # 创建片段文件名并导出
        segment_filename = f"{start_time_seconds:.3f}s.wav"
        segment_filepath = os.path.join(output_dir, segment_filename)
        print(f"正在导出片段: {segment_filepath}")
        write_wav(segment_filepath, amplified_pcm_data, CHANNELS, SAMPWIDTH, FRAMERATE)

        # 为合并做准备
        final_pcm_data_list.append(amplified_pcm_data)
        
        # 更新已处理的总采样数
        num_samples_in_segment = len(amplified_pcm_data) // SAMPWIDTH
        total_samples_processed += num_samples_in_segment

    # --- 步骤 3: 合并所有片段并导出最终文件 ---
    if final_pcm_data_list:
        combined_pcm_data = b''.join(final_pcm_data_list)
        combined_filepath = os.path.join(output_dir, combined_filename)
        
        print(f"\n正在导出合并后的文件: {combined_filepath}")
        write_wav(combined_filepath, combined_pcm_data, CHANNELS, SAMPWIDTH, FRAMERATE)
        
        print("\n所有任务完成")
    else:
        print("\n没有可处理的音频数据")

if __name__ == "__main__":
    main()

s = "651466314514271616614214660701456661601411451426071146666014214371656514214470"

from functools import lru_cache

@lru_cache(None)
def dp(i):
    if i == len(s):
        return [[]]  # 分割到末尾返回空解
    res = []
    for l in (2, 3):  # 尝试2或3位八进制段
        if i + l <= len(s):
            part = s[i:i+l]
            val = int(part, 8)  # 按八进制解析
            if 32 <= val <= 126:  # 判断是否可打印
                for tail in dp(i + l):
                    res.append([val] + tail)
    return res

solutions = dp(0)
if solutions:
    for vals in solutions:
        decoded = "".join(chr(v) for v in vals)
        print(decoded)

from pwn import *
from hashlib import sha256
import string
import itertools
from functools import reduce

# --- Config ---
context.log_level = 'info'
HOST = '39.106.45.147'
PORT = 39009

# --- PoW Solver ---
def solve_pow(p):
    p.recvuntil(b'sha256(XXXX+')
    suffix = p.recvuntil(b')', drop=True).decode()
    p.recvuntil(b'== ')
    target_hash = p.recvline().strip().decode()
    
    log.info(f"Solving PoW: sha256(XXXX+{suffix}) == {target_hash}")
    
    for prefix in itertools.product(string.ascii_letters + string.digits, repeat=4):
        prefix_str = "".join(prefix)
        guess = (prefix_str + suffix).encode()
        if sha256(guess).hexdigest() == target_hash:
            log.success(f"PoW solved! XXXX = {prefix_str}")
            p.sendlineafter(b'Give me XXXX: ', prefix_str.encode())
            return
    
    log.error("PoW failed!")
    exit(1)

# --- Helper for Parity Calculation ---
def calculate_parity(booleans):
    if not booleans: return True
    return reduce(lambda a, b: a == b, booleans)

# --- Main Logic for a Single Round ---
def solve_round(p):
    log.info("Starting new round with Parity Code query set...")
    
    questions = []
    # 1. 8 direct queries
    for i in range(8):
        questions.append(f"S{i}")
    
    # 2. 9 parity check queries for maximum error correction capability
    parity_indices = [
        [0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 4, 5], 
        [2, 3, 6, 7], [0, 2, 4, 6], [1, 3, 5, 7],
        [0, 3, 5], [1, 2, 6], [0, 4, 7]
    ]
    for indices in parity_indices:
        questions.append(" == ".join([f"S{i}" for i in indices]))

    responses = []
    for i, q in enumerate(questions):
        # On the first question of a round, check the received preamble for the gift
        received_data = p.sendlineafter(b"Ask your question:", q.encode(), timeout=5)
        
        if i == 0 and b"Here is a gift for you:" in received_data:
            for line in received_data.strip().split(b'\n'):
                if b"Here is a gift for you:" in line:
                    log.warning(f"GIFT RECEIVED: {line.decode()}")

        p.recvuntil(b"Prisoner's response: ")
        res = p.recvline().strip().decode().replace("!", "")
        responses.append(res == 'True')

    possible_solutions = []
    for i in range(256):
        candidate_secrets = [(i >> j) & 1 == 1 for j in range(8)]
        
        true_results = candidate_secrets[:]
        for indices in parity_indices:
            vals_for_parity = [candidate_secrets[k] for k in indices]
            parity_val = calculate_parity(vals_for_parity)
            true_results.append(parity_val)

        distance = sum(1 for j in range(17) if responses[j] != true_results[j])
        
        if distance == 2:
            possible_solutions.append(candidate_secrets)

    # Handle the rare but real cases of ambiguity
    if len(possible_solutions) >= 1:
        if len(possible_solutions) > 1:
            log.warning(f"AMBIGUITY DETECTED: Found {len(possible_solutions)} solutions. Guessing the first one.")
        else:
            log.success(f"Found unique solution: {possible_solutions[0]}")
        solution = possible_solutions[0]
    else: # len == 0
        log.error("FATAL: Found NO possible solutions. The logic is flawed or the server is inconsistent.")
        p.interactive()
        exit(1)
        
    solution_str = " ".join(map(str, map(int, solution)))
    p.sendlineafter(b"Now reveal the true secrets (1 for true, 0 for false):", solution_str.encode())


# --- Main Connection Handler ---
def main():
    try:
        p = remote(HOST, PORT)
        solve_pow(p)
        
        for i in range(25):
            log.info(f"--- Starting Round {i+1}/25 ---")
            solve_round(p)
            
            # Check for success or failure to prevent hanging on a closed socket
            response = p.recvline(timeout=3)
            if b"laughs triumphantly" in response:
                log.error("Round failed, likely due to an unlucky ambiguous case.")
                log.error("The server has closed the connection. Please restart the script.")
                return

        log.success("All rounds completed! Receiving flag...")
        p.interactive()
    except EOFError:
        log.error("Connection closed unexpectedly. This can happen after a failed round.")
        log.warning("Please re-run the script.")


if __name__ == "__main__":
    main()

import sys
from pathlib import Path

def ror64_1_le(block8: bytes) -> bytes:
    # rotate-right by 1 bit on the 64-bit little-endian value
    v = int.from_bytes(block8, 'little')
    v = ((v >> 1) | ((v & 1) << 63)) & ((1 << 64) - 1)
    return v.to_bytes(8, 'little')

def swap_each_16bit_bytes(b: bytes) -> bytes:
    # swap bytes within each 16-bit lane: [b0 b1][b2 b3]... -> [b1 b0][b3 b2]...
    ba = bytearray(b)
    for i in range(0, len(ba), 2):
        if i + 1 < len(ba):
            ba[i], ba[i+1] = ba[i+1], ba[i]
    return bytes(ba)

def per_byte_sub(a: bytes, key8: bytes) -> bytes:
    return bytes(((a[i] - key8[i % 8]) & 0xFF) for i in range(len(a)))

def per_byte_xor(a: bytes, key8: bytes) -> bytes:
    return bytes((a[i] ^ key8[i % 8]) for i in range(len(a)))

def decrypt_block(block8: bytes, key8: bytes) -> bytes:
    # Encryption: c = paddb( rol64( swap16( x ^ key )), key )
    # Decryption: x = ( swap16( ror64( c - key )) ) ^ key
    t1 = per_byte_sub(block8, key8)
    t2 = ror64_1_le(t1)
    t3 = swap_each_16bit_bytes(t2)
    plain = per_byte_xor(t3, key8)
    return plain

def load_key8(key_path: Path) -> bytes:
    # Try to read first 8 bytes from key file, fallback to b"MMXEncod"
    fallback = b"MMXEncode2024"[:8]
    try:
        data = key_path.read_bytes()
        if len(data) >= 8:
            return data[:8]
    except Exception:
        pass
    return fallback

def main():
    enc_path = Path("encode.dat")
    key_path = Path("encode.dat.key")
    if not enc_path.exists():
        print("encode.dat not found", file=sys.stderr)
        sys.exit(1)

    key8 = load_key8(key_path)

    enc = enc_path.read_bytes()
    out = bytearray()
    n = len(enc)
    # process full 8-byte blocks
    full_blocks = (n // 8)
    for i in range(full_blocks):
        blk = enc[i*8:(i+1)*8]
        out.extend(decrypt_block(blk, key8))
    # tail bytes remain unchanged (encrypter仅对满8字节块处理)
    tail = enc[full_blocks*8:]
    if tail:
        out.extend(tail)

    # print to stdout (binary-safe)
    sys.stdout.buffer.write(bytes(out))

if __name__ == "__main__":
    main()