LAIN vs Knights

Flag: ECW{L41N_15_7H3_0NLY_0N3_WHO_C4N_ST0P_M3}

Challenge

Description

---

**Level 3 - UART HARDWARE

LAIN vs THE WIRED**

Welcome to The Wired: A digital labyrinth of over a thousand mysterious nodes, where only seven are protected by the legendary Knights.

You are Lain. Your mission: Navigate this cryptic UART interface, explore The Wired, and uncover the locations of the hidden Knights. Purge each Knight !

Each defeated Knight grants you a fragment. Collect all seven fragments to unlock the final gateway : EIRI MASAMI — the master of The Wired.

Seize root access. Become the new legend of The Wired.

Format: ECW{flag}

Challenge made by Eun0us from:

Ce challenge tourne sur un docker et n'est pas disponible

Solution

Ce challenge est la suite de LAIN_Breakcore. Je réutilise la classe de base pour discuter avec le serveur, mais avec quelques modifications. Pour une question de simplicité, j'ai séparé en différents fichiers Python.

static.py

HOST = "challenges.challenge-ecw.eu"
TX = 35061
RX = 35062

uart.py

from time import sleep
from pwn import remote, context

context.log_level = "critical"

class UART:
    def __init__(self, host: str, tx: int, rx: int) -> None:
        self.tx = remote(host, tx)
        self.rx = remote(host, rx)
        self.tx.timeout = 2
        self.rx.timeout = 2

    def read(self, n: int, print_str=True, decode=True) -> str|bytes:
        data = self.tx.recv(n)
        if decode:
          data = data.decode()
        if print_str:
            print(data, end="")
        return data
    
    def read_until(self, until: bytes, print_str=True) -> str:
        data = self.tx.recvuntil(until).decode()
        if print_str:
            print(data, end="")
        return data

    def write(self, data: str, print_str=True, read_response=0) -> str|None:
        if print_str:
            print(data)
        self.rx.sendline(data.encode())
        sleep(0.1)
        if read_response > 0:
            return self.read(read_response, print_str=print_str)

---

Reconnaissance du challenge

Première chose à faire, énumerer les commandes et savoir quoi faire

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('help', read_response=2048)
uart.write('system.status', read_response=2048)
uart.write('system.mission', read_response=2048)
uart.write('bus.map', read_response=2048)
uart.write('system.scan bus', read_response=2048)

[BOOT]
┌─ THE WIRED ──────────────────────────────────────────┐
│AION μCore v4.10 — Tachibana Labs                   │
│channels:512   phase=0.608   base=200ms   jitter=±7%│
│TX=11111 (read)  RX=12222 (write)                   │
│Try: help   •   whereami   •   system.scan bus      │
└────────────────────────────────────────────────────┘
[CTX]
node:0073 (noise=rain, entropy=0.843)
[PROMPT]
lain@node:0073>
help
[PROMPT]
lain@node:0073>
[CMD]
help
[HELP]
whereami | system.status | system.fragments | system.mission | system.scan bus | bus.connect @node:ID | bus.peek @node:ID | bus.map | bus.transmit @node:ID "payload"
Inside node: node.help | node.echo "..." | node.easter | node.fragments
[PROMPT]
lain@node:0073>
system.status
[CMD]
system.status
[STATUS]
context=node:0073  phase=0.608 base=200ms jitter=±7%  fragments=[-] caps=[-]
[PROMPT]
lain@node:0073>
system.mission
[CMD]
system.mission
[MISSION]
MISSION STATUS:
The Wired network is unstable. Seven legendary hardware Knights each guard a critical fragment of the root exploit.
Your objective is to seek out and defeat the Knights in sequence, collect all 7 fragments, and assemble the final exploit at the Founder node.

Order of Knights:
  1. Knight of Mirrors (I2C Mirror)
  2. Knight of Streams (CAN Checksum)
  3. Knight of Flesh (SPI Parity)
  4. Knight of Noise (SRAM Write)
  5. Knight of Truth (Logic AND)
  6. Knight of Syntax (Fuse Bits)
  7. Knight of Light (Fault Injection)

Progress:
- Defeat the Knights, collect their fragments (one per Knight, in order), and return to the Founder node to submit your assembled exploit.
- Root The Wired. Become Lain.
[PROMPT]
lain@node:0073>
bus.map
[CMD]
bus.map
[NAVY]
1200 nodes total — 7 knights active.
[PROMPT]
lain@node:0073>
system.scan bus
[CMD]
system.scan bus
[NAVY]
1200 nodes detected — 131 exceed entropy threshold (not all are anomalies). Connect & observe.
[PROMPT]
lain@node:0073>

Il y a 1200 nodes, et 7 chevaliers sont cachés dans celles-ci. Il faut tous les défaire pour réussir le challenge.

---

Scan des nodes

Maintenant il faut trouver les chevaliers, donc on va tout scanner

import json
from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

with open('scan.txt', 'w') as f:
    for i in range(1, 1201):
        data = uart.write(f'bus.peek @node:{i}', read_response=2048, print_str=False)
        assert type(data) is str
        line = next((line for line in data.splitlines() if line.startswith('{"id"')), "")
        node = json.loads(line)
        if node["kind"] != "normal":
            f.write(line + "\n")

{"id": 16, "entropy": 0.91, "latency_ms": 21, "kind": "lain"}
{"id": 56, "entropy": 0.805, "latency_ms": 46, "kind": "lain"}
{"id": 126, "entropy": 0.802, "latency_ms": 48, "kind": "knight:i2c_mirror"}
{"id": 134, "entropy": 0.34, "latency_ms": 30, "kind": "knight:can_checksum"}
{"id": 235, "entropy": 0.168, "latency_ms": 6, "kind": "knight:spi_parity"}
{"id": 288, "entropy": 0.468, "latency_ms": 35, "kind": "founder"}
{"id": 379, "entropy": 0.842, "latency_ms": 8, "kind": "knight:sram_write"}
{"id": 465, "entropy": 0.32, "latency_ms": 27, "kind": "lain"}
{"id": 484, "entropy": 0.29, "latency_ms": 5, "kind": "lain"}
{"id": 616, "entropy": 0.334, "latency_ms": 24, "kind": "knight:logic_and"}
{"id": 673, "entropy": 0.8, "latency_ms": 57, "kind": "lain"}
{"id": 688, "entropy": 0.682, "latency_ms": 46, "kind": "lain"}
{"id": 786, "entropy": 0.542, "latency_ms": 50, "kind": "knight:fuse_bits"}
{"id": 919, "entropy": 0.428, "latency_ms": 48, "kind": "lain"}
{"id": 1030, "entropy": 0.719, "latency_ms": 47, "kind": "lain"}
{"id": 1118, "entropy": 0.376, "latency_ms": 58, "kind": "lain"}
{"id": 1146, "entropy": 0.376, "latency_ms": 56, "kind": "knight:fault_injection"}

On a trouvé tous les chevaliers, mais on voit qu'il y a aussi des nodes lain. Celles-ci contiennent des informations complémentaires sur le challenge.

En se connectant à l'une d'entre elle, on a des commandes exclusives, notamment node.truth. En spammant cette commande, on peut y apprendre :

import json
from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:73')    # 73 est une node lain pour moi
uart.read_until(b'>\x1b[0m\n')
uart.read_until(b'>\x1b[0m\n')
for i in range(10):
  uart.write('node.truth', read_response=2048)

[LAIN:0073]
We are all part of Wired.
Collect the fragments from all 7 hardware knights.
We all love lain <3
Order matters. Use: i2c_mirror, can_checksum, spi_parity, sram_write, logic_and, fuse_bits, fault_injection.
Assemble fragments in this order as a single string, with no separators.
Hash this string using SHA256.
Take the first 24 hex digits of the hash.
[LAIN] - U got it? that ur exploit !!!
That is all I can tell you...
That is all I can tell you...

Allez, c'est parti pour le grind, purgeons ces chevaliers !

---

1. Knight of I2C MIRROR

Ici il faut envoyer deux nombres dont la somme des octets donnent la même chose modulo X.

Bon, on va pas s'embêter et simplement envoyer 00 et X. Ici j'avais mod 163, donc j'envoie 00 et A3 :

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:126',read_response=2048)
uart.write(f'node.submit_pair "00" "{163:0>2X}"',read_response=2048)
uart.read(2048)

[KNIGHT:0013]
┌─ Knight of I2C MIRROR ──────────────────────────────────────────────────────────────────────────────────────────────────┐
│ ___    ___    ___        __  __  ___  ___  ___   ___   ___                                                            │
│|_ _|  |_  )  / __|      |  \/  ||_ _|| _ \| _ \ / _ \ | _  | |    / /  | (__       | |\/| | | | |   /|   /| (_) ||   /│
│|___|  /___|  \___|      |_|  |_||___||_|_\|_|_\ \___/ |_|_    Knight of i2c_mirror                                    │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
[KNIGHT:0126]
Find two distinct messages with the same sum of bytes mod 163.
[KNIGHT:0126]
Use: node.i2c_write "<hex>" | node.submit_pair "<m1>" "<m2>"
[CTX]
node:0126 (noise=echo, entropy=0.802)
[PROMPT]
lain@node:0126>
node.submit_pair "00" "A3"
[CMD]
node.submit_pair "00" "A3"
[KNIGHT:0126]
granted: knight_i2c_mirror ; fragment i2c_mirror=00_A3
[KNIGHT:0126]
[i2c_mirror] mirror broken, knight purged.

---

2. Knight of Streams

Là il faut trouver un message dont le CRC8 donne X. Subtilité : le poly change. Je suis donc parti sur la lib Python crc. Ensuite, on bruteforce en local un octet qui donne le résultat attendu :

from uart import UART
from static import HOST, TX, RX
from crc import Calculator, Configuration

config = Configuration(
    width=8,
    polynomial=0x2F,
    init_value=0x00,
    final_xor_value=0x00,
    reverse_input=False,
    reverse_output=False,
)
calculator = Calculator(config)

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:134',read_response=2048)
for i in range(256):
  if calculator.checksum(bytes([i])) == 0xc4:
    uart.write(f'node.can_send "{i:0>2X}"',read_response=2048)
    uart.read(2048)

[KNIGHT:0134]
┌─ Knight of Streams ──────────────────────────────────────────────────────┐
│  ___  ___  _  _         ___  _  _  ___   ___  _  __ ___  _   _  __  __ │
│ / __|/   \| \| |       / __|| || || __| / __|| |/ // __|| | | ||  \/  |│
│| (__ | - || .  |      | (__ | __ || _| | (__ |   < \__ \| |_| || |\/| |│
│ \___||_|_||_|\_|       \___||_||_||___| \___||_|\_\|___/ \___/ |_|  |_|│
│    Knight of CAN CHECKSUM                                              │
└────────────────────────────────────────────────────────────────────────┘
[KNIGHT:0134]
Find a CAN frame whose CRC8 is 0x41 (poly=0x2F).
[KNIGHT:0134]
Use: node.can_send "<hex>"
[CTX]
node:0134 (noise=glitch, entropy=0.340)
[PROMPT]
lain@node:0134>
node.can_send "5A"
[CMD]
node.can_send "5A"
[KNIGHT:0134]
CRC8 = 41
[KNIGHT:0134]
granted: knight_can_checksum ; fragment can_checksum=5A
[KNIGHT:0134]
[can_checksum] checksum validated, knight purged.

---

3. Knight of SPI PARITY

Un des plus simple, on se casse pas la tête. On me demande un nombre qui a 5 transitions de bits : 01010111.

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:235',read_response=2048)
n = int('01010111', 2)
uart.write(f'node.spi_write {n}',read_response=2048)
uart.read(2048)

[KNIGHT:0235]
┌─ Knight of SPI PARITY ──────────────────────────────┐
│ ___  ___  ___        ___             _  _    _  _ │
│/ __|| _ \|_ _|      | _ \ __ _  _ _ (_)| |_ | || |│
│\__ \|  _/ | |       |  _// _` || '_|| ||  _| \_. |│
│|___/|_|  |___|      |_|  \__/_||_|  |_| \__| |__/ │
│    Knight of spi_parity                           │
└───────────────────────────────────────────────────┘
[KNIGHT:0235]
Find a byte with 5 bit transitions (0↔1). node.spi_write <byte>
[CTX]
node:0235 (noise=null, entropy=0.168)
[PROMPT]
lain@node:0235>
node.spi_write 87
[CMD]
node.spi_write 87
[KNIGHT:0235]
SPI: 01010111 → transitions: 5
[KNIGHT:0235]
granted: knight_spi_parity ; fragment spi_parity=57
[KNIGHT:0235]
[spi_parity] signal stabilized, knight purged.

---

4. Knight of SRAM Write

Aussi connu sous le nom de chevalier clown, c'est le plus simple des défis. On envoi ce qui est demandé...

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:379',read_response=2048)
uart.write(f'node.write 0x9b 0x59',read_response=2048)
uart.read(2048)

[KNIGHT:0379]
┌─ Knight of SRAM Write ───┐
│ ___  ___  ___  __  __  │
│/ __|| _ \/   \|  \/  | │
│\__ \|   /| - || |\/| | │
│|___/|_|_\|_|_||_|  |_| │
│    Knight of sram_write│
└────────────────────────┘
[KNIGHT:0379]
Write value 0x59 to address 0x9b.
[KNIGHT:0379]
Use: node.write <addr> <value>
[CTX]
node:0379 (noise=echo, entropy=0.842)
[PROMPT]
lain@node:0379>
node.write 0x9b 0x59
[CMD]
node.write 0x9b 0x59
[KNIGHT:0379]
granted: knight_sram_write ; fragment sram_write=9b_59
[KNIGHT:0379]
[sram_write] pattern matched, knight purged.

---

5. Knight of LOGIC AND

Ici on commence par envoyer n'importe quoi, ça nous dira que le résultat est différent du secret en le leakant.

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:616',read_response=2048)
uart.write(f'node.submit_and {0xff} {0xff}',read_response=2048)
uart.read(2048)

Incorrect AND result: 0xff & 0xff != 0x00

J'ai eu le secret 0x00 mais ça peut-être n'importe quoi. Il ne reste plus qu'à envoyer le secret avec 0xff pour que le résultat du AND donne le secret.

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:616',read_response=2048)
uart.write(f'node.submit_and {0x00} {0xff}',read_response=2048)
uart.read(2048)

[KNIGHT:0616]
┌─ Knight of LOGIC AND ───────────────────────────┐
│ ___           _        _          __ _  _     │
│/   \ _ _   __| |      | |    ___ / _` |(_) __ │
│| - || ' \ / _` |      | |__ / _ \__. || |/ _| │
│|_|_||_||_|\__/_|      |____|\___/|___/ |_|\__|│
│    Knight of logic_and                        │
└───────────────────────────────────────────────┘
[KNIGHT:0616]
Find a pair (a, b) whose AND equals the secret.
[KNIGHT:0616]
Use: node.and_probe <a> <b> | node.submit_and <a> <b>
[CTX]
node:0616 (noise=glitch, entropy=0.334)
[PROMPT]
lain@node:0616>
node.submit_and 0 255
[CMD]
node.submit_and 0 255
[KNIGHT:0616]
granted: knight_logic_and ; fragment logic_and=00_ff
[KNIGHT:0616]
[logic_and] correct pair, knight purged.

---

6. Knight of FUSE BITS

Là il faut trouver le secret après application de notre masque. On envoie donc 0xff pour récupérer le secret : 0x3a ici.

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:786',read_response=2048)
uart.write(f'node.fuse_probe {0b11111111}',read_response=2048)
uart.read(2048)

[CMD]
node.fuse_probe 255
[KNIGHT:0786]
Probe: (fuse & 0xff) = 0x0a

Maintenant on soumet le secret récupéré :

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:786',read_response=2048)
uart.write(f'node.submit_fuse {0x0a}',read_response=2048)
uart.read(2048)

[KNIGHT:0786]
┌─ Knight of FUSE BITS ───────────────────────┐
│ ___                       ___  _  _       │
│| __| _  _  ___ ___       | _ )(_)| |_  ___│
│| _| | || |(_-// -_)      | _ \| ||  _|(_-/│
│|_|   \_._|/__/\___|      |___/|_| \__|/__/│
│    Knight of fuse_bits                    │
└───────────────────────────────────────────┘
[KNIGHT:0786]
Guess the secret fuse bitmask (8 bits).
[KNIGHT:0786]
Use: node.fuse_probe <mask> | node.submit_fuse <guess>
[CTX]
node:0786 (noise=glitch, entropy=0.542)
[PROMPT]
lain@node:0786>
node.submit_fuse 10
[CMD]
node.submit_fuse 10
[KNIGHT:0786]
granted: knight_fuse_bits ; fragment fuse_bits=0a
[KNIGHT:0786]
[fuse_bits] bits aligned, knight purged.

---

7. Knight of FAULT INJECTION

Honnêtement le plus relou. J'ai peut-être pas compris ce qui était attendu donc je propose un bruteforce tout simplement. On nous demande un offset et un mask pour bitflip le bon bit (qu'on connait pas).

from time import sleep
from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('bus.connect @node:1146',read_response=2048)
for offset in range(8):
  for i in range(8):
    mask = 0b1 << i
    data = uart.write(f'node.inject {offset} {mask}', read_response=2048)
    try:
      data = data.split('[KNIGHT:')[1].splitlines()[1]
      if 'has no effect' not in data:
        uart.read(2048)
        break
    except:
      uart.read(2048)

[KNIGHT:1146]
┌─ Knight of FAULT INJECTION ─────────────────────────────────────────────────┐
│ ___              _  _          ___         (_)          _    _            │
│| __| __ _  _  _ | || |_       |_ _| _ _    | | ___  __ | |_ (_) ___  _ _  │
│| _| / _` || || || ||  _|       | | | ' \  _/ |/ -_)/ _||  _|| |/ _ \| ' \ │
│|_|  \__/_| \_._||_| \__|      |___||_||_||__/ \___|\__| \__||_|\___/|_||_|│
│    Knight of fault_injection                                              │
└───────────────────────────────────────────────────────────────────────────┘
[KNIGHT:1146]
Flip the right bit at the right offset.
[KNIGHT:1146]
Use: node.inject <offset> <mask>
[CTX]
node:1146 (noise=glitch, entropy=0.376)
[PROMPT]
lain@node:1146>
node.inject 0 1
[CMD]
node.inject 0 1
[KNIGHT:1146]
Fault at 0, mask 0x01 has no effect.
[PROMPT]
lain@node:1146>
node.inject 0 2
[CMD]
node.inject 0 2
[KNIGHT:1146]
Fault at 0, mask 0x02 has no effect.

[...]

[CMD]
node.inject 6 8
[KNIGHT:1146]
granted: knight_fault_injection ; fragment fault_injection=6_08
[KNIGHT:1146]
[fault_injection] injected, knight purged.

---

Founder

from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

uart.write('system.fragments', read_response=2048)

[CMD]
system.fragments
[FRAGMENTS]
Fragments collected:
fault_injection = 6_08
i2c_mirror = 00_A3
can_checksum = 5A
spi_parity = 57
sram_write = 9b_59
logic_and = 00_ff
fuse_bits = 0a

Maintenant, il faut simplement suivre ce que LAIN nous a dit au début : on assemble les fragments dans le bon ordre, on applique un SHA256 dessus et on ne garde que les 24 premier caractères hex.

from hashlib import sha256
from uart import UART
from static import HOST, TX, RX

uart = UART(HOST, TX, RX)
uart.read(2048)

# Fragments
# fault_injection = 6_08
# i2c_mirror = 00_A3
# can_checksum = 5A
# spi_parity = 57
# sram_write = 9b_59
# logic_and = 00_ff
# fuse_bits = 0a

# Ordre : i2c_mirror, can_checksum, spi_parity, sram_write, logic_and, fuse_bits, fault_injection

payload = sha256(b"00_A35A579b_5900_ff0a6_08").hexdigest()[:24]

uart.write('bus.connect @node:288',read_response=2048)
uart.write(f'node.exploit {payload}',read_response=2048)
uart.read(2048)
uart.write(f'node.flag',read_response=2048)

[FOUNDER:0288]
┌─ Eiri Masami ───────────────────────────────────────────────────────────┐
│ ▄▄   ▄▄ ▄▄▄▄▄▄ ▄▄▄▄▄▄▄ ▄▄▄▄▄▄ ▄▄   ▄▄ ▄▄▄    ▄▄▄▄▄▄▄ ▄▄▄ ▄▄▄▄▄▄   ▄▄▄ │
│█  █▄█  █      █       █      █  █▄█  █   █  █       █   █   ▄  █ █   █│
│█       █  ▄   █  ▄▄▄▄▄█  ▄   █       █   █  █    ▄▄▄█   █  █ █ █ █   █│
│█       █ █▄█  █ █▄▄▄▄▄█ █▄█  █       █   █  █   █▄▄▄█   █   █▄▄█▄█   █│
│█       █      █▄▄▄▄▄  █      █       █   █  █    ▄▄▄█   █    ▄▄  █   █│
│█ ██▄██ █  ▄   █▄▄▄▄▄█ █  ▄   █ ██▄██ █   █  █   █▄▄▄█   █   █  █ █   █│
│█▄█   █▄█▄█ █▄▄█▄▄▄▄▄▄▄█▄█ █▄▄█▄█   █▄█▄▄▄█  █▄▄▄▄▄▄▄█▄▄▄█▄▄▄█  █▄█▄▄▄█│
│        Tachibana general Laboratories.                                │
└───────────────────────────────────────────────────────────────────────┘
[FOUNDER:0288]
To root The Wired, submit your assembled exploit.
[FOUNDER:0288]
Endpoints: node.exploit <hex> | node.flag
[FOUNDER:0288]
Status: YOU ARE ROOT. node.flag to retrieve flag.
[CTX]
node:0288 (noise=hush, entropy=0.468)
[PROMPT]
lain@node:0288>
node.exploit 0d88b00da0d8ccba3c8bbe8e
[CMD]
node.exploit 0d88b00da0d8ccba3c8bbe8e
[FOUNDER:0288]
[ROOT] Exploit accepted! You are now root.
[FOUNDER:0288]
Use node.flag to retrieve the flag.
[FOUNDER:0288]
LAIN is the only one who can stop me now...
[PROMPT]
lain@node:0288>
node.flag
[CMD]
node.flag
[FOUNDER:0288]
FLAG: ECW{L41N_15_7H3_0NLY_0N3_WHO_C4N_ST0P_M3}
[PROMPT]