import os
from collections import Counter

def can_analysis(file_path):
    if not os.path.exists(file_path):
        print(f"Error: {file_path} not found.")
        return

    # 1. 原始数据解析
    raw_packets = []
    id_list = []
    
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            parts = line.strip().split()
            if len(parts) < 3: continue
            try:
                raw_packets.append({
                    'line': int(parts[0]),
                    'id': parts[1],
                    'hex': parts[2],
                    'val': int(parts[2], 16)
                })
                id_list.append(parts[1])
            except ValueError:
                continue

    # 2. 统计每个 ID 的出现频率
    id_counts = Counter(id_list)
    avg_freq = sum(id_counts.values()) / len(id_counts)
    
    # 3. 锁定干扰数据
    # 干扰数据通常是发送次数最少，或者明显偏离正常周期频率的 ID
    # 这里我们取出现频率最低的 ID
    sorted_by_freq = sorted(id_counts.items(), key=lambda x: x[1])
    interference_id = sorted_by_freq[0][0] 

    # 4. 锁定车速信号
    # 物理信号 ID 拥有最多的“唯一数值数量”
    # 因为它在加速和减速过程中几乎每一帧产生的物理值都不同
    id_uniqueness = {}
    for packet in raw_packets:
        if packet['id'] == interference_id: continue # 排除干扰帧
        
        if packet['id'] not in id_uniqueness:
            id_uniqueness[packet['id']] = set()
        id_uniqueness[packet['id']].add(packet['hex'])
    
    # 找到不重复数值最多的 ID
    speed_id = max(id_uniqueness, key=lambda k: len(id_uniqueness[k]))

    # 5. 在锁定的车速信号中寻找峰值
    speed_packets = [p for p in raw_packets if p['id'] == speed_id]
    peak_packet = max(speed_packets, key=lambda x: x['val'])

    # --- 输出结论 ---
    print(f"[*] 发现干扰数据 ID      : {interference_id}")
    print(f"    (判定依据: 该 ID 出现频率最低，共 {id_counts[interference_id]} 次)")
    
    print(f"[*] 锁定车速信号 ID      : {speed_id}")
    print(f"    (判定依据: 数据熵最高，拥有 {len(id_uniqueness[speed_id])} 个独立物理状态)")
    
    print("-" * 50)
    print(f"[*] 车辆达到的极限峰值   : {peak_packet['val']}")
    print(f"[*] 峰值数据原始载荷     : {peak_packet['hex']}")
    print(f"[*] 峰值发生的行位置 : 第 {peak_packet['line']} 行")

if __name__ == "__main__":
    can_analysis('can_data.txt')

import numpy as np
from scipy.io import wavfile
from scipy import signal

def restore_audio():
    print("[-] Loading raw data files...")
    # GNU Radio File Sink 保存的是 raw binary float32
    try:
        i_data = np.fromfile('flag1.txt', dtype=np.float32)
        q_data = np.fromfile('flag2.txt', dtype=np.float32)
    except FileNotFoundError:
        print("[!] Error: flag1.txt or flag2.txt not found.")
        return

    # 确保两个文件长度一致
    min_len = min(len(i_data), len(q_data))
    i_data = i_data[:min_len]
    q_data = q_data[:min_len]

    print(f"[-] Data loaded. Samples: {min_len}")

    # 1. 组合 I/Q 信号 (Complex IQ)
    # Z = I + jQ
    iq_signal = i_data + 1j * q_data

    print("[-] Demodulating FM signal...")

    # 2. FM 解调 (Quadrature Demodulation)
    # 原理: FM 信号的信息包含在瞬时频率中。
    # 离散域中，瞬时频率与相邻采样点的相位差成正比。
    #通过计算 sample[n] * conj(sample[n-1]) 的角度来获得相位差。

    # 将信号错位 1 位进行共轭相乘
    # angle( Z[n] * Z[n-1]* )
    demodulated_signal = np.angle(iq_signal[1:] * np.conj(iq_signal[:-1]))

    # 3. 降采样 (Decimation)
    # 流图参数: 
    #   USRP Rate = 576k
    #   IF Rate (quad_rate) = 576k / 3 = 192k (这是 flag 文件的采样率)
    #   Audio Rate (samp_rate) = 48k
    # 因此需要进行 192k -> 48k 的降采样，因子为 4。
    # 使用 scipy.signal.decimate 可以自动进行低通滤波防止混叠。

    print("[-] Decimating (192kHz -> 48kHz)...")
    decimation_factor = 4
    audio_output = signal.decimate(demodulated_signal, decimation_factor)

    # 4. 去加重 (Optional but Recommended)
    # NBFM 发射端通常有预加重 (Pre-emphasis)，接收端应该去加重 (De-emphasis)。
    # 这里可以简单地使用一个低通滤波器，或者如果不做也能听清内容。
    # 为了简化，这里我们只依靠 decimate 自带的滤波，通常足够还原语音。

    # 5. 归一化并保存
    # 归一化到 -1.0 到 1.0 之间，防止爆音
    print("[-] Normalizing and saving...")
    audio_output = audio_output / np.max(np.abs(audio_output))

    # 写入 WAV 文件 (48kHz)
    output_filename = 'password.wav'
    wavfile.write(output_filename, 48000, audio_output.astype(np.float32))

    print(f"[+] Audio saved to {output_filename}")

if __name__ == '__main__':
    restore_audio()

import numpy as np
from PIL import Image

img = Image.open('blue.png')
img_array = np.array(img)
blue_channel = img_array[:, :, 2]
blue_bytes = blue_channel.tobytes()

high_nibbles = []
for byte in blue_bytes:
    high_nibble = (byte >> 4) & 0x0F
    high_nibbles.append(high_nibble)

combined_bytes = bytearray()
for i in range(0, len(high_nibbles) - len(high_nibbles) % 2, 2):
    combined_byte = (high_nibbles[i] << 4) | high_nibbles[i + 1]
    combined_bytes.append(combined_byte)

with open('blue.zip', 'wb') as f:
    f.write(combined_bytes)

import re
from PIL import Image
import math

def get_closest_dimensions(total):
    root = int(math.sqrt(total))
    for w in range(root, 0, -1):
        if total % w == 0:
            h = total // w
            return w, h
    return 1, total

def main():
    try:
        with open('document.xml', 'r', encoding='utf-8') as f:
            content = f.read()
    except FileNotFoundError:
        return

    # 提取被单独封装在一个 Run 里的彩色空格
    pattern = r'<w:r><w:rPr><w:color w:val="([0-9A-Fa-f]{6})"/></w:rPr><w:t xml:space="preserve"> </w:t></w:r>'

    colors = re.findall(pattern, content)
    total_pixels = len(colors)

    if total_pixels == 0:
        return

    # 计算宽高
    w_base, h_base = get_closest_dimensions(total_pixels)

    dimensions = [(w_base, h_base)]
    if w_base != h_base:
        dimensions.append((h_base, w_base))

    for _, (width, height) in enumerate(dimensions):
        img = Image.new('RGB', (width, height))

        for i in range(total_pixels):
            hex_color = colors[i]
            r = int(hex_color[0:2], 16)
            g = int(hex_color[2:4], 16)
            b = int(hex_color[4:6], 16)

            x = i % width
            y = i // width
            img.putpixel((x, y), (r, g, b))

        img.save('result.png')

if __name__ == '__main__':
    main()