decode_spi_xor.py

#!/usr/bin/env python3
import json
import sys
from itertools import cycle

def load_events(path):
    events = []
    with open(path, "r") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            events.append(json.loads(line))
    events.sort(key=lambda e: e["t"])
    return events

def sample_mosi_at_sck(mosi_events, sck_events):
    """
    For each SCK event with marker 'sample', take the last MOSI value
    at or before that timestamp.
    """
    bits = []
    m_idx = 0
    last_mosi_val = mosi_events[0]["v"]

    for s in sck_events:
        if s.get("marker") != "sample":
            continue
        t_sck = s["t"]

        # advance MOSI index until we pass this SCK time
        while m_idx + 1 < len(mosi_events) and mosi_events[m_idx + 1]["t"] <= t_sck:
            m_idx += 1
            last_mosi_val = mosi_events[m_idx]["v"]

        bits.append(last_mosi_val)

    return bits

def bits_to_bytes_msb_first(bits):
    out = []
    for i in range(0, len(bits), 8):
        chunk = bits[i:i+8]
        if len(chunk) < 8:
            break
        val = 0
        for b in chunk:
            val = (val << 1) | (b & 1)  # MSB-first
        out.append(val)
    return out

def xor_decrypt(data_bytes, key_str):
    key_bytes = key_str.encode("ascii")
    out = []
    for b, k in zip(data_bytes, cycle(key_bytes)):
        out.append(b ^ k)
    return out

def bytes_to_ascii(data_bytes):
    return "".join(chr(b) if 32 <= b < 127 else "." for b in data_bytes)

def main():
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} mosi.json sck.json", file=sys.stderr)
        sys.exit(1)

    mosi_path = sys.argv[1]
    sck_path = sys.argv[2]

    # 1. Load events
    mosi_events = load_events(mosi_path)
    sck_events = load_events(sck_path)

    if not mosi_events or not sck_events:
        print("No events found in one of the files.", file=sys.stderr)
        sys.exit(1)

    # 2. Build bitstream using SCK sample markers
    bits = sample_mosi_at_sck(mosi_events, sck_events)
    if not bits:
        print("No bits decoded (check markers 'sample' / file format).", file=sys.stderr)
        sys.exit(1)

    # 3. Convert bits to bytes (MSB-first)
    spi_bytes = bits_to_bytes_msb_first(bits)

    # 4. Print raw SPI data
    print("Raw SPI data:")
    print("HEX  :", " ".join(f"{b:02x}" for b in spi_bytes))
    print("ASCII:", bytes_to_ascii(spi_bytes))
    print()

    # 5. Decrypt using XOR key 'icy'
    xor_key = "icy"
    decrypted = xor_decrypt(spi_bytes, xor_key)

    print(f"Decrypted SPI data using XOR key '{xor_key}':")
    print("HEX  :", " ".join(f"{b:02x}" for b in decrypted))
    print("ASCII:", bytes_to_ascii(decrypted))

if __name__ == "__main__":
    main()