import csv
import base58
import os

input_file_path = "sheidongleheixian.csv"
file_name_without_ext, file_extension = os.path.splitext(input_file_path)
output_file_path = f"{file_name_without_ext}_decoded{file_extension}"

new_column_name = 'decoded_tx_hash'

processed_rows = []
header = []


with open(input_file_path, 'r', encoding='utf-8') as infile:
    reader = csv.DictReader(infile)

    header = reader.fieldnames

    for row in reader:
        tx_hash_val = row.get('tx_hash', '')
        decoded_value = ''

        decoded_bytes = base58.b58decode(tx_hash_val)
        decoded_value = decoded_bytes.decode('utf-8') 

        row[new_column_name] = decoded_value
        processed_rows.append(row)

new_fieldnames = header + [new_column_name]

with open(output_file_path, 'w', encoding='utf-8', newline='') as outfile:
    writer = csv.DictWriter(outfile, fieldnames=new_fieldnames)
    writer.writeheader()
    writer.writerows(processed_rows)

import pandas as pd
from collections import defaultdict

def find_transaction_chains(csv_path):
    """
    从交易数据中还原出交易链。
    """
    try:
        # 1. 加载数据
        df = pd.read_csv(csv_path)
        print(f"成功加载 {len(df)} 条交易记录。")
    except FileNotFoundError:
        print(f"错误: 文件未找到，请检查路径 '{csv_path}' 是否正确。")
        return []

    # 2. 按时间戳排序，这是构建链条的基础
    df = df.sort_values(by='timestamp').reset_index(drop=True)

    # 3. 建立一个从 'from_address' 到其发起交易的快速查找字典
    transactions_by_sender = defaultdict(list)
    all_transactions = df.to_dict('records')

    for tx in all_transactions:
        transactions_by_sender[tx['from_address']].append(tx)

    # 4. 遍历和构建链条
    chains = []
    visited_hashes = set()

    for tx in all_transactions:
        # 如果当前交易已经被包含在某个链中，则跳过
        if tx['tx_hash'] in visited_hashes:
            continue

        # 发现了一个新链条的起点
        current_chain = []
        current_tx = tx

        # 循环追踪链条，直到中断
        while current_tx is not None:
            # 将当前交易加入链条，并标记为已访问
            current_chain.append(current_tx)
            visited_hashes.add(current_tx['tx_hash'])

            # 寻找下一个环节：当前交易的接收方是否是下一笔交易的发送方？
            next_sender = current_tx['to_address']
            
            next_tx_candidate = None
            # 检查这个接收方是否发起过任何交易
            if next_sender in transactions_by_sender:
                # 遍历该发送方的所有交易，找到第一个尚未被访问的交易
                for potential_next_tx in transactions_by_sender[next_sender]:
                    if potential_next_tx['tx_hash'] not in visited_hashes:
                        next_tx_candidate = potential_next_tx
                        break # 找到了，跳出内层循环
            
            # 更新current_tx，如果没找到下一个环节，它会变为None，循环终止
            current_tx = next_tx_candidate

        # 将构建完成的链条存入结果列表
        chains.append(current_chain)
        
    return chains

def print_chains_summary(chains):
    """打印找到的交易链的摘要信息"""
    print("\n" + "="*50)
    print(f"分析完成！共找到 {len(chains)} 条独立的交易链。")
    print("="*50 + "\n")

    # 按链条长度从长到短排序
    chains.sort(key=len, reverse=True)

    for i, chain in enumerate(chains):
        print(f"--- 链条 {i+1} (长度: {len(chain)}) ---")
        
        # 打印链条的起点和终点
        start_addr = chain[0]['from_address']
        end_addr = chain[-1]['to_address']
        
        print(f"  起点地址: {start_addr}")
        print(f"  终点地址: {end_addr}")

        path_str = chain[0]['from_address']
        for tx in chain:
            path_str += f" --({tx['decoded_tx_hash']})--> {tx['to_address']}"
        print(f"  路径: {path_str}")



if __name__ == "__main__":
    FILE_PATH = "sheidongleheixian_decoded.csv"
    found_chains = find_transaction_chains(FILE_PATH)
    if found_chains:
        print_chains_summary(found_chains)

import pandas as pd

file_path = "sheidongleheixian_decoded.csv"
df = pd.read_csv(file_path)
pattern = r'^tx.*[a-z]'
filtered_df = df[df['decoded_tx_hash'].str.contains(pattern, regex=True)]
print(filtered_df['decoded_tx_hash'])

import hashlib

def generate_key(secret: str) -> list[int]:
    """
    根据 sub_11B9 的逻辑从密钥字符串生成加密密钥。
    """
    sha256 = hashlib.sha256(secret.encode()).digest()
    d = sha256[:4]
    
    # k = [k0, k1, k2, k3]
    key = [0] * 4
    key[0] = d[0] | 1
    key[1] = d[1] & 0xFE
    key[2] = d[2] & 0xFE
    key[3] = d[3] | 1
    
    return key

def get_inverse_matrix(key: list[int]) -> list[int]:
    """
    计算加密矩阵在模256下的逆矩阵。
    """
    k0, k1, k2, k3 = key
    
    # 计算行列式 det(K) = (k0*k3 - k1*k2) mod 256
    det = (k0 * k3 - k1 * k2) % 256
    
    # 计算行列式的模256乘法逆元
    # 在 Python 3.8+ 中，可以直接使用 pow(det, -1, 256)
    try:
        det_inv = pow(det, -1, 256)
    except ValueError:
        raise ValueError(f"Determinant {det} has no modular inverse for modulus 256")

    # 计算逆矩阵 K_inv = det_inv * [[k3, -k1], [-k2, k0]] mod 256
    inv_matrix = [0] * 4
    inv_matrix[0] = (det_inv * k3) % 256
    inv_matrix[1] = (det_inv * -k1) % 256
    inv_matrix[2] = (det_inv * -k2) % 256
    inv_matrix[3] = (det_inv * k0) % 256
    
    return inv_matrix

def decrypt_block(cipher_block: bytes, inv_matrix: list[int]) -> bytes:
    """
    使用逆矩阵解密一个2字节的数据块。
    P = K_inv * C mod 256
    """
    c0, c1 = cipher_block
    m0, m1, m2, m3 = inv_matrix
    
    p0 = (m0 * c0 + m1 * c1) % 256
    p1 = (m2 * c0 + m3 * c1) % 256
    
    return bytes([p0, p1])

def solve():
    """
    主函数，执行完整的解密流程并输出Flag。
    """
    # .data:0000000000004080
    byte_4080 = bytes([
        0x00, 0x00, 0x00, 0x25, 0x0C, 0xE2, 0x70, 0x89, 0x98, 0xB2, 0xBB, 0xE4,
        0x94, 0xA0, 0x95, 0xAC, 0x38, 0x92, 0x22, 0xF8, 0x0E, 0x7B, 0x76, 0x1A,
        0x66, 0xC8, 0x03, 0x05, 0x2E, 0x7D, 0xA1, 0x04, 0x3D, 0xC0, 0x62, 0xFE,
        0x66, 0x67, 0x02, 0x87, 0x81, 0xF4, 0x00, 0x00
    ])

    # 1. 生成密钥
    secret = "MySecretKey123!"
    key = generate_key(secret)
    print(f"🔑 生成的加密密钥 (k0,k1,k2,k3): {key}")

    # 2. 计算逆矩阵
    inv_matrix = get_inverse_matrix(key)
    print(f"🔢 逆矩阵 (mod 256): {inv_matrix}")
    
    # 3. 提取密文和明文长度
    original_len = int.from_bytes(byte_4080[:4], 'big')
    ciphertext = byte_4080[4:]
    
    decrypted_padded = bytearray()
    
    # 4. 循环解密
    # 将密文按4字节分块
    for i in range(0, len(ciphertext), 4):
        chunk = ciphertext[i : i+4]
        if len(chunk) < 4:
            # 处理可能的填充不完整情况（虽然在此题中不会发生）
            continue
            
        # 将4字节块分成两个2字节块并解密
        decrypted_padded.extend(decrypt_block(chunk[0:2], inv_matrix))
        decrypted_padded.extend(decrypt_block(chunk[2:4], inv_matrix))

    # 5. 截取原始长度，得到Flag
    flag = decrypted_padded[:original_len].decode('utf-8')
    
    print("\n" + "="*40)
    print(f"🚩 解密得到的 Flag: {flag}")
    print("="*40)

if __name__ == "__main__":
    solve()