scapy>=2.5.0

#!/usr/bin/env python3
"""Passive packet capture to PCAP; does not modify or forward traffic."""
import argparse
from pathlib import Path
from scapy.all import sniff, PcapWriter

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--iface", required=True)
    ap.add_argument("--out", default="capture.pcap")
    ap.add_argument("--filter", default="")
    ap.add_argument("--count", type=int, default=0, help="0 = until Ctrl-C")
    args = ap.parse_args()
    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
    writer = PcapWriter(args.out, append=False, sync=True)
    print(f"Passive capture on {args.iface}; output={args.out}; Ctrl-C to stop")
    try:
        sniff(iface=args.iface, filter=args.filter or None, count=args.count,
              prn=writer.write, store=False)
    except KeyboardInterrupt:
        pass
    finally:
        writer.close()
        print(f"Saved capture: {args.out}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Local-only HTTP fixture for testing your own client/parser."""
import argparse
from http.server import BaseHTTPRequestHandler, HTTPServer

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        body = b"local-lab-ok"
        self.send_response(200)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        self.wfile.write(body)
    def log_message(self, fmt, *args):
        print("%s - %s" % (self.client_address[0], fmt % args))

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--host", default="127.0.0.1",
                    help="Defaults to localhost; do not expose this fixture to public networks")
    ap.add_argument("--port", type=int, default=8088)
    args = ap.parse_args()
    if args.host not in ("127.0.0.1", "::1", "localhost"):
        raise SystemExit("Safety check: fixture must bind to loopback only.")
    print(f"Local fixture listening on http://{args.host}:{args.port}")
    HTTPServer((args.host, args.port), Handler).serve_forever()

if __name__ == "__main__":
    main()

# Switch 2 Network Research Lab (safe, passive/offline)

This suite is designed for authorized observation and **offline** protocol analysis.
It does not spoof Nintendo, bypass TLS, forward console traffic, or transmit mutated
packets to a console. Mutated DNS examples are written to PCAP files for inspection
or testing against a local mock parser that you control.

## Requirements
- Linux
- Python 3.10+
- `pip install -r requirements.txt`
- For live capture: run with sufficient privileges (usually `sudo`).

## Quick start
```bash
python3 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt

# Passive capture (replace interface and filter as needed)
sudo .venv/bin/python network_monitor.py --iface wlan0 --out captures/session.pcap \
  --filter "host 10.0.0.90"

# Summarize an existing capture
python pcap_analyzer.py captures/session.pcap

# Generate offline DNS mutation corpus as a PCAP (does NOT send it)
python offline_dns_corpus.py --pcap captures/dns-corpus.pcap --count 30

# Start a harmless local HTTP test endpoint, bound to localhost only
python local_http_fixture.py --host 127.0.0.1 --port 8088
```

## Safety boundaries
- Capture only networks/devices you own or are explicitly authorized to test.
- PCAP files may contain identifiers, cookies, tokens, or other sensitive data.
  Keep them private; redact before sharing.
- Do not replay generated PCAPs against the Switch or Nintendo infrastructure.
- No certificate interception, credential collection, exploit payloads, or crash-triggering
  traffic is implemented.

#!/usr/bin/env python3
"""Create a harmless offline DNS response corpus in PCAP format; never transmits."""
import argparse, random
from scapy.all import Ether, IP, UDP, DNS, DNSQR, DNSRR, wrpcap

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--pcap", default="dns-corpus.pcap")
    ap.add_argument("--count", type=int, default=30)
    ap.add_argument("--seed", type=int, default=7)
    args = ap.parse_args()
    random.seed(args.seed)
    packets = []
    qname = "lab.invalid."
    for i in range(args.count):
        qid = i + 1
        base = DNS(id=qid, qr=1, rd=1, ra=1, qd=DNSQR(qname=qname))
        mode = i % 6
        if mode == 0:
            dns = base / DNSRR(rrname=qname, type="A", ttl=60, rdata="192.0.2.10")
        elif mode == 1:
            dns = base.copy()
            dns.tc = 1
            dns.ancount = 0
        elif mode == 2:
            dns = base.copy()
            dns.ancount = 0
            dns.rcode = 3
        elif mode == 3:
            dns = base.copy()
            dns.ancount = 0
            dns.arcount = 0
        elif mode == 4:
            dns = base / DNSRR(rrname=qname, type="TXT", ttl=1, rdata="offline-test")
        else:
            dns = base / DNSRR(rrname=qname, type="A", ttl=0, rdata="198.51.100.7")
        packets.append(Ether()/IP(src="192.0.2.1", dst="192.0.2.2")/
                       UDP(sport=53, dport=53000)/dns)
    wrpcap(args.pcap, packets)
    print(f"Wrote {len(packets)} offline test packets to {args.pcap}; nothing was transmitted.")

if __name__ == "__main__":
    main()

## 1. Descargar y descomprimir

Descarga el proyecto:

switch2_network_lab_suite.zip[Switch 2 Network Research Lab](sandbox:/mnt/data/switch2_network_lab_suite.zip)

En Linux:

```bash
unzip switch2_network_lab_suite.zip
cd switch2_lab_suite
```

## 2. Instalar dependencias

```bash
sudo apt update
sudo apt install python3 python3-pip python3-venv -y

python3 -m venv .venv
source .venv/bin/activate

pip install -r requirements.txt
```

## 3. Utilizar los scripts

### A. Monitorizar tráfico de red

Primero identifica tu interfaz:

```bash
ip -br addr
```

Inicia la captura (sustituye `wlan0` por tu interfaz):

```bash
sudo .venv/bin/python network_monitor.py \
--iface wlan0 \
--out captures/session.pcap
```

Para detenerla: `CTRL+C`.

### B. Analizar tráfico capturado

```bash
python pcap_analyzer.py captures/session.pcap
```

Obtendrás:
- Protocolos detectados.
- Direcciones IP.
- Puertos.
- Consultas DNS.
- Información TLS SNI visible.

### C. Generar muestras DNS

```bash
python offline_dns_corpus.py \
--pcap captures/dns-corpus.pcap \
--count 100
```

Genera 100 muestras DNS para análisis offline.

### D. Iniciar servidor HTTP local

```bash
python local_http_fixture.py
```

Accede a:

```text
http://127.0.0.1:8088
```

### E. Utilizar el orquestador

Generar muestras:

```bash
python orchestrator.py dns-corpus --count 100
```

Analizar una captura:

```bash
python orchestrator.py analyze captures/session.pcap
```

Iniciar monitorización:

```bash
sudo .venv/bin/python orchestrator.py capture --iface wlan0
```

---

## 4. Flujo de trabajo recomendado

1. Inicia la monitorización.
2. Conecta tu Switch 2 a tu red de laboratorio.
3. Realiza operaciones normales en la consola.
4. Detén la captura.
5. Analiza el PCAP.
6. Identifica protocolos y comportamientos anómalos.
7. Genera corpus offline para estudiar los parsers.

**Nota:** La captura depende de la topología de red y de que tu interfaz pueda observar el tráfico de la consola.

La suite actual es una primera versión de investigación pasiva; todavía no implementa fuzzing automatizado de DNS, NTP, TLS y HTTP contra dispositivos reales.

#!/usr/bin/env python3
"""Offline PCAP summary: endpoints, DNS names, protocols, and TLS SNI when visible."""
import argparse
from collections import Counter
from scapy.all import rdpcap, IP, IPv6, TCP, UDP, DNS, DNSQR
from scapy.layers.tls.all import TLS, TLSClientHello

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("pcap")
    ap.add_argument("--top", type=int, default=30)
    args = ap.parse_args()
    packets = rdpcap(args.pcap)
    protocols, endpoints, dns_names, sni_names = Counter(), Counter(), Counter(), Counter()
    for p in packets:
        ip = p.getlayer(IP) or p.getlayer(IPv6)
        if not ip:
            protocols["non-IP"] += 1
            continue
        proto = "TCP" if p.haslayer(TCP) else "UDP" if p.haslayer(UDP) else str(ip.nh if p.haslayer(IPv6) else ip.proto)
        protocols[proto] += 1
        if p.haslayer(TCP):
            t = p[TCP]
            endpoints[f"{ip.src}:{t.sport} -> {ip.dst}:{t.dport}"] += 1
        elif p.haslayer(UDP):
            u = p[UDP]
            endpoints[f"{ip.src}:{u.sport} -> {ip.dst}:{u.dport}"] += 1
        if p.haslayer(DNS) and p[DNS].qd and isinstance(p[DNS].qd, DNSQR):
            q = p[DNS].qd.qname
            dns_names[q.decode(errors="replace") if isinstance(q, bytes) else str(q)] += 1
        # Scapy TLS dissector may expose SNI on supported ClientHello records.
        try:
            if p.haslayer(TLSClientHello):
                hello = p[TLSClientHello]
                for ext in getattr(hello, "ext", []) or []:
                    names = getattr(ext, "servernames", None)
                    if names:
                        for item in names:
                            name = getattr(item, "servername", b"")
                            sni_names[name.decode(errors="replace") if isinstance(name, bytes) else str(name)] += 1
        except Exception:
            pass
    print(f"Packets: {len(packets)}")
    for title, counter in (("Protocols", protocols), ("Endpoints", endpoints),
                           ("DNS queries", dns_names), ("Visible TLS SNI", sni_names)):
        print(f"\\n{title}:")
        for key, count in counter.most_common(args.top):
            print(f"  {count:6}  {key}")

if __name__ == "__main__":
    main()

(pentestai.txt) - Necesito scripts que me hagan esto.



He revisado el contenido de tu enlace.

Lo que necesitas es una **suite de herramientas de investigación y fuzzing para Nintendo Switch 2**, utilizando Python y Scapy.

Puedo prepararte estos scripts:

| Script | Funcionalidad |
|---|---|
| `network_monitor.py` | Captura y clasifica el tráfico de la Switch 2. |
| `dns_fuzzer.py` | Genera respuestas DNS con estructuras y longitudes anómalas para probar el parser. |
| `ntp_fuzzer.py` | Prueba el procesamiento de paquetes NTP malformados. |
| `http_fuzzer.py` | Prueba la robustez del procesamiento HTTP. |
| `tls_fuzzer.py` | Comprueba el comportamiento ante respuestas TLS inválidas. |
| `crash_monitor.py` | Monitoriza desconexiones, reinicios y anomalías. |
| `packet_logger.py` | Registra los paquetes enviados y recibidos para reproducir pruebas. |
| `orchestrator.py` | Coordina las pruebas, registra resultados y controla los intervalos. |

### Características
- Python 3.
- Linux.
- Scapy.
- Registro detallado de cada prueba.
- Identificador único por paquete.
- Control de frecuencia de envío.
- Ejecución individual o automatizada.
- Reproducción de pruebas.
- Sin modificar el firmware de la consola.

**Una pregunta:** ¿Quieres que prepare toda la suite integrada, con todos los scripts independientes y un orquestador central, para realizar investigación de vulnerabilidades en tu propia Switch 2?

Suite preparada.

**switch2_network_lab_suite.zip[Descargar Switch 2 Network Research Lab](sandbox:/mnt/data/switch2_network_lab_suite.zip)**

### Contenido

| Archivo | Función |
|---|---|
| `network_monitor.py` | Captura pasiva de tráfico. |
| `pcap_analyzer.py` | Analiza archivos PCAP. |
| `offline_dns_corpus.py` | Genera muestras DNS para análisis offline. |
| `local_http_fixture.py` | Servidor HTTP local de pruebas. |
| `orchestrator.py` | Coordina las herramientas. |
| `requirements.txt` | Dependencias. |
| `README.md` | Instalación y utilización. |

### Instalación

```bash
unzip switch2_network_lab_suite.zip
cd switch2_lab_suite

python3 -m venv .venv
source .venv/bin/activate

pip install -r requirements.txt
```

### Importante

Esta primera versión permite observación, análisis y generación offline de muestras de protocolos. No inyecta paquetes malformados en la consola ni modifica su tráfico.

**Siguiente fase:** desarrollar un entorno de fuzzing controlado con corpus, mutaciones, cobertura, detección de anomalías y reproducción de casos, sin poner en riesgo la consola.

#!/usr/bin/env python3
"""Launcher for passive capture and offline analysis."""

import argparse
import json
import subprocess
import sys
import threading
from collections import Counter
from pathlib import Path


def run(cmd):
    print("+", " ".join(cmd), flush=True)
    return subprocess.call(cmd)


def show_packet_stats(process):
    """
    Lee eventos JSON desde stdout del proceso hijo.
    Formato esperado: {"event": "packet_sent", "port": 443}
    """
    counts = Counter()

    for line in process.stdout:
        try:
            event = json.loads(line)
        except json.JSONDecodeError:
            print(line, end="", flush=True)
            continue

        if event.get("event") != "packet_sent":
            continue

        port = event.get("port")
        if not isinstance(port, int):
            continue

        counts[port] += 1

        status = " | ".join(
            f"{port}: {count}"
            for port, count in sorted(counts.items())
        )

        sys.stdout.write(f"\rPaquetes enviados por puerto: {status:<70}")
        sys.stdout.flush()

    if counts:
        print()


def run_with_stats(cmd):
    print("+", " ".join(cmd), flush=True)

    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=None,
        text=True,
        bufsize=1,
    )

    show_packet_stats(process)
    return process.wait()


def main():
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="action", required=True)

    c = sub.add_parser("capture")
    c.add_argument("--iface", required=True)
    c.add_argument("--out", default="captures/session.pcap")
    c.add_argument("--filter", default="")

    a = sub.add_parser("analyze")
    a.add_argument("pcap")

    d = sub.add_parser("dns-corpus")
    d.add_argument("--out", default="captures/dns-corpus.pcap")
    d.add_argument("--count", type=int, default=30)

    args = ap.parse_args()
    py = sys.executable

    if args.action == "capture":
        return run([
            py, "network_monitor.py",
            "--iface", args.iface,
            "--out", args.out,
            "--filter", args.filter,
        ])

    if args.action == "analyze":
        return run([py, "pcap_analyzer.py", args.pcap])

    if args.action == "dns-corpus":
        Path(args.out).parent.mkdir(parents=True, exist_ok=True)
        return run([
            py, "offline_dns_corpus.py",
            "--pcap", args.out,
            "--count", str(args.count),
        ])


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3

import socket
import struct
import threading
import email.utils
from http.server import BaseHTTPRequestHandler, HTTPServer

# CONFIGURACIÓN
PORTATIL_IP = "10.0.0.1"

NINTENDO_BODY = b"ok"
NINTENDO_CTYPE = "text/plain"


# ---------------- DNS ----------------

def dns_server():
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((PORTATIL_IP, 53))

    print("[DNS] Escuchando en 0.0.0.0:53", flush=True)

    while True:
        data, addr = sock.recvfrom(512)

        try:
            transaction_id = data[:2]
            flags = struct.unpack("!H", data[2:4])[0]
            qdcount = struct.unpack("!H", data[4:6])[0]

            if qdcount == 0:
                continue

            offset = 12
            labels = []

            while data[offset] != 0:
                length = data[offset]
                offset += 1
                labels.append(data[offset:offset + length].decode())
                offset += length

            offset += 1
            qtype, qclass = struct.unpack("!HH", data[offset:offset + 4])
            question = data[12:offset + 4]

            domain = ".".join(labels).lower()

            if qtype == 1 and qclass == 1:
                ip = PORTATIL_IP
                answer = (
                    b"\xc0\x0c"
                    + struct.pack("!HHIH", 1, 1, 60, 4)
                    + socket.inet_aton(ip)
                )

                response = (
                    transaction_id
                    + struct.pack("!HHHHH", 0x8180, 1, 1, 0, 0)
                    + question
                    + answer
                )

                print(f"[DNS] {addr[0]} -> {domain} = {ip}", flush=True)

            else:
                response = (
                    transaction_id
                    + struct.pack("!HHHHH", 0x8180, 1, 0, 0, 0)
                    + question
                )

            sock.sendto(response, addr)

        except Exception as e:
            print(f"[DNS] Error: {e}", flush=True)


# ---------------- HTTP ----------------

class H(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def _send_nintendo(self):
        now = email.utils.formatdate(usegmt=True)

        self.send_response(200)
        self.send_header("Content-Type", NINTENDO_CTYPE)
        self.send_header("Content-Length", str(len(NINTENDO_BODY)))
        self.send_header("Expires", now)
        self.send_header("Cache-Control", "max-age=0, no-cache, no-store")
        self.send_header("Pragma", "no-cache")
        self.send_header("Date", now)
        self.send_header("Connection", "close")
        self.send_header("X-Organization", "Nintendo")
        self.end_headers()

        self.wfile.write(NINTENDO_BODY)

    def do_GET(self):
        host = self.headers.get("Host", "").split(":")[0]

        print(
            f"{self.client_address[0]} Host={host} GET {self.path}",
            flush=True
        )

        if "nintendo" in host or "ctest" in host:
            return self._send_nintendo()

        self.send_response(404)
        self.send_header("Content-Length", "0")
        self.end_headers()

    def do_HEAD(self):
        host = self.headers.get("Host", "").split(":")[0]

        if "nintendo" in host or "ctest" in host:
            now = email.utils.formatdate(usegmt=True)

            self.send_response(200)
            self.send_header("Content-Type", NINTENDO_CTYPE)
            self.send_header("Content-Length", str(len(NINTENDO_BODY)))
            self.send_header("Expires", now)
            self.send_header("Cache-Control", "max-age=0, no-cache, no-store")
            self.send_header("Pragma", "no-cache")
            self.send_header("Date", now)
            self.send_header("Connection", "close")
            self.send_header("X-Organization", "Nintendo")
            self.end_headers()
            return

        self.send_response(404)
        self.send_header("Content-Length", "0")
        self.end_headers()

    def log_message(self, fmt, *args):
        pass


# ---------------- INICIO ----------------

threading.Thread(target=dns_server, daemon=True).start()

print("[HTTP] Falso internet Nintendo en 0.0.0.0:80", flush=True)

HTTPServer(("0.0.0.0", 80), H).serve_forever()

ò
j]__(wk
aEQ@aj
Z

25=)

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm5@
@


ZEQ@aj
Z

25=)

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@ai
Z

25=K	.;

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm6@
?


ZEQ@ai
Z

25=K	.;

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@ah
Z

Ҕ5=θ)

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm7@
>


ZEQ@ah
Z

Ҕ5=θ)

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@ag
Z

Ҕ5=t.;

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm8@
=


ZEQ@ag
Z

Ҕ5=t.;

dauthp01lp1ndassrvnintendonet
j)__(wk
aEQ@af
Z

5=Z)

dauthp01lp1ndassrvnintendonet

j4{{k
a(wEm9@
<


ZEQ@af
Z

5=Z)

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@ae
Z

5=YI.;

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm:@
;


ZEQ@ae
Z

5=YI.;

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@ad
Z

M5=)

dauthp01lp1ndassrvnintendonet

jf__(wk
aEQ@ac
Z

M5=.;

dauthp01lp1ndassrvnintendonet
j**R}r3

R}r3
j**R}r3

R}r3
jd
__(wk
aEQ@ab
Z

M5=)

dauthp01lp1ndassrvnintendonet

j
{{k
a(wEm@



ZEQ@ab
Z

M5=)

dauthp01lp1ndassrvnintendonet

j
__(wk
aEQ@aa
Z

M5=.;

dauthp01lp1ndassrvnintendonet
j
{{k
a(wEm@



ZEQ@aa
Z

M5=.;

dauthp01lp1ndassrvnintendonet
j**R}r3

R}r3
j**R}r3

R}r3
j$**R}r3

R}r3
j$**R}r3

R}r3
jF**R}r3

R}r3
jk**R}r3

R}r3
jUx__(wk
aEQ@a`
Z

5=

dauthp01lp1ndassrvnintendonet

jwx{{k
a(wEm@
ȯ


ZEQ@a`
Z

5=

dauthp01lp1ndassrvnintendonet

jy__(wk
aEQ@a_
Z

5=Yc1

dauthp01lp1ndassrvnintendonet
jy{{k
a(wEm@
Ȯ


ZEQ@a_
Z

5=Yc1

dauthp01lp1ndassrvnintendonet
jg__(wk
aEQ@a^
Z

*<5=xW

dauthp01lp1ndassrvnintendonet

ju{{k
a(wEm@
ȭ


ZEQ@a^
Z

*<5=xW

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@a]
Z

*<5=	1

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm@
Ȭ


ZEQ@a]
Z

*<5=	1

dauthp01lp1ndassrvnintendonet
j___(wk
aEQ@a\
Z

5=

dauthp01lp1ndassrvnintendonet

jk{{k
a(wEm@
Ȫ


ZEQ@a\
Z

5=

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@a[
Z

5=5Y1

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm@
ȩ


ZEQ@a[
Z

5=5Y1

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@aZ
Z

~
5=$

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aY
Z

~
5=lD1

dauthp01lp1ndassrvnintendonet
j{__(wk
aEQ@aX
Z

~
5=$

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm@
Ĭ


ZEQ@aX
Z

~
5=$

dauthp01lp1ndassrvnintendonet

j,__(wk
aEQ@aW
Z

~
5=lD1

dauthp01lp1ndassrvnintendonet
j1{{k
a(wEm@
ī


ZEQ@aW
Z

~
5=lD1

dauthp01lp1ndassrvnintendonet
jJ__(wk
aEQ@aV
Z

5=

dauthp01lp1ndassrvnintendonet

jo{{k
a(wEm@
v


ZEQ@aV
Z

5=

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aU
Z

5=ND,

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm@
u


ZEQ@aU
Z

5=ND,

dauthp01lp1ndassrvnintendonet
j,__(wk
aEQ@aT
Z

<5=

dauthp01lp1ndassrvnintendonet

jD{{k
a(wEm@
s


ZEQ@aT
Z

<5=

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aS
Z

<5=HD,

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm@
r


ZEQ@aS
Z

<5=HD,

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@aR
Z

5=

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm@
q


ZEQ@aR
Z

5=

dauthp01lp1ndassrvnintendonet

jj__(wk
aEQ@aQ
Z

5=kD,

dauthp01lp1ndassrvnintendonet
jm{{k
a(wEm@
p


ZEQ@aQ
Z

5=kD,

dauthp01lp1ndassrvnintendonet
jK__(wk
aEQ@aP
Z

5=

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aO
Z

5=D,

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@aN
Z

5=

dauthp01lp1ndassrvnintendonet

jT{{k
a(wEm@



ZEQ@aN
Z

5=

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aM
Z

5=D,

dauthp01lp1ndassrvnintendonet
j{{k
a(wEm@



ZEQ@aM
Z

5=D,

dauthp01lp1ndassrvnintendonet
jJi
__(wk
aEQ@aL
Z

r5=@

dauthp01lp1ndassrvnintendonet

j`s
__(wk
aEQ@aK
Z

r5=x

dauthp01lp1ndassrvnintendonet
jYY__(wk
aEQ@aJ
Z

r5=@

dauthp01lp1ndassrvnintendonet

j<Z__(wk
aEQ@aI
Z

r5=x

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@aH
Z

r5=@

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@aG
Z

r5=x

dauthp01lp1ndassrvnintendonet
jߔ__(wk
aEQ@aF
Z

r5=@

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm@



ZEQ@aF
Z

r5=@

dauthp01lp1ndassrvnintendonet

j>__(wk
aEQ@aE
Z

r5=x

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@aD
Z

5=@

dauthp01lp1ndassrvnintendonet

j~__(wk
aEQ@aC
Z

5=_x

dauthp01lp1ndassrvnintendonet
jq**(wR}r3

R}r3
jH**R}r3

R}r3
jl**R}r3

R}r3
j	__(wk
aEQ@aB
Z

}5=}

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm‚@



ZEQ@aB
Z

}5=}

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ
@aA
Z

}5=\5

dauthp01lp1ndassrvnintendonet
j	{{k
a(wEmƒ@



ZEQ
@aA
Z

}5=\5

dauthp01lp1ndassrvnintendonet
j	__(wk
aEQ@a@
Z

I5=}

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm…@



ZEQ@a@
Z

I5=}

dauthp01lp1ndassrvnintendonet

je	__(wk
aEQ@a?
Z

I5=V/5

dauthp01lp1ndassrvnintendonet
jn	{{k
a(wEm†@



ZEQ@a?
Z

I5=V/5

dauthp01lp1ndassrvnintendonet
j	__(wk
aEQ@a>
Z

5=H}

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm‡@



ZEQ@a>
Z

5=H}

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ@a=
Z

5=5

dauthp01lp1ndassrvnintendonet
j|	__(wk
aEQ@a<
Z

+5=E0}

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ@a;
Z

+5=5

dauthp01lp1ndassrvnintendonet
j<**R}r3

R}r3
j=**R}r3

R}r3
j**R}r3

R}r3
j**R}r3

R}r3
j
__(wk
aEQ@a:
Z

+5=E0}

dauthp01lp1ndassrvnintendonet

j:
{{k
a(wEm+@
J


ZEQ@a:
Z

+5=E0}

dauthp01lp1ndassrvnintendonet

j]
__(wk
aEQ	@a9
Z

+5=5

dauthp01lp1ndassrvnintendonet
jb
{{k
a(wEm,@
I


ZEQ	@a9
Z

+5=5

dauthp01lp1ndassrvnintendonet
jE__(wk
aEQ
@a8
Z

i5=?

dauthp01lp1ndassrvnintendonet

jG__(wk
aEQ@a7
Z

i5=

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@a6
Z

i5=?

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ
@a5
Z

i5=

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@a4
Z

i5=?

dauthp01lp1ndassrvnintendonet

j3{{k
a(wEmp@



ZEQ@a4
Z

i5=?

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ@a3
Z

i5=

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ@a2
Z

5=

dauthp01lp1ndassrvnintendonet

jC__(wk
aEQ@a1
Z

5=

dauthp01lp1ndassrvnintendonet
jh**R}r3

R}r3
j**R}r3

R}r3
j-	__(wk
aEQ@a0
Z

5=

dauthp01lp1ndassrvnintendonet

jZ	{{k
a(wEml@
	


ZEQ@a0
Z

5=

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ@a/
Z

5=

dauthp01lp1ndassrvnintendonet
j	{{k
a(wEmm@



ZEQ@a/
Z

5=

dauthp01lp1ndassrvnintendonet
jE
__(wk
aEQ@a.
Z

|5=}%}

dauthp01lp1ndassrvnintendonet

jE
__(wk
aEQ@a-
Z

|5=5L

dauthp01lp1ndassrvnintendonet
j**k
a(w

(w


Zj**(wk
a
k
a
Z(w

jx4__(wk
aEQ@a,
Z

|5=}%}

dauthp01lp1ndassrvnintendonet

j7__(wk
aEQ@a+
Z

|5=5L

dauthp01lp1ndassrvnintendonet
jj__(wk
aEQ@a*
Z

|5=}%}

dauthp01lp1ndassrvnintendonet

j-__(wk
aEQ@a)
Z

|5=5L

dauthp01lp1ndassrvnintendonet
j	**R}r3

R}r3
j$	**R}r3

R}r3
j>S__(wk
aEQ@a(
Z

|5=}%}

dauthp01lp1ndassrvnintendonet

jcS{{k
a(wEm͹@



ZEQ@a(
Z

|5=}%}

dauthp01lp1ndassrvnintendonet

jS__(wk
aEQ@a'
Z

|5=5L

dauthp01lp1ndassrvnintendonet
jW__(wk
aEQ@a&
Z

%5=%}

dauthp01lp1ndassrvnintendonet

j>Y__(wk
aEQ@a%
Z

%5=L

dauthp01lp1ndassrvnintendonet
jT	__(wk
aEQ@a$
Z

95=V

dauthp01lp1ndassrvnintendonet

jy	{{k
a(wEm2@
C


ZEQ@a$
Z

95=V

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ@a#
Z

95=]

dauthp01lp1ndassrvnintendonet
j	{{k
a(wEm3@
B


ZEQ@a#
Z

95=]

dauthp01lp1ndassrvnintendonet
j	__(wk
aEQ @a"
Z

z]5=AV

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm4@
A


ZEQ @a"
Z

z]5=AV

dauthp01lp1ndassrvnintendonet

ja	__(wk
aEQ!@a!
Z

z]5=@

dauthp01lp1ndassrvnintendonet
ji	{{k
a(wEm5@
@


ZEQ!@a!
Z

z]5=@

dauthp01lp1ndassrvnintendonet
j	__(wk
aEQ"@a 
Z

5=!V

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm7@
>


ZEQ"@a 
Z

5=!V

dauthp01lp1ndassrvnintendonet

j	__(wk
aEQ#@a
Z

5=

dauthp01lp1ndassrvnintendonet
j$	__(wk
aEQ$@a
Z

(g5=V

dauthp01lp1ndassrvnintendonet

jB	__(wk
aEQ%@a
Z

(g5=n6

dauthp01lp1ndassrvnintendonet
jA
__(wk
aEQ&@a
Z

(g5=V

dauthp01lp1ndassrvnintendonet

j_
{{k
a(wEmز@



ZEQ&@a
Z

(g5=V

dauthp01lp1ndassrvnintendonet

j[
__(wk
aEQ'@a
Z

(g5=n6

dauthp01lp1ndassrvnintendonet
jd
{{k
a(wEmس@



ZEQ'@a
Z

(g5=n6

dauthp01lp1ndassrvnintendonet
j$5__(wk
aEQ(@a
Z

5=<}

dauthp01lp1ndassrvnintendonet

jP5__(wk
aEQ)@a
Z

5=][

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ*@a
Z

5=<}

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ+@a
Z

5=][

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ,@a
Z

5=<}

dauthp01lp1ndassrvnintendonet

j{{k
a(wEm۳@



ZEQ,@a
Z

5=<}

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ-@a
Z

5=][

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ.@a
Z

5=-}

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ/@a
Z

5=[

dauthp01lp1ndassrvnintendonet
j	__(wk
aEQ0@a
Z

5=-}

dauthp01lp1ndassrvnintendonet

j	{{k
a(wEm@



ZEQ0@a
Z

5=-}

dauthp01lp1ndassrvnintendonet

j/	__(wk
aEQ1@a
Z

5=[

dauthp01lp1ndassrvnintendonet
j2	{{k
a(wEm@



ZEQ1@a
Z

5=[

dauthp01lp1ndassrvnintendonet
j__(wk
aEQ2@a
Z

|h5=])

dauthp01lp1ndassrvnintendonet

j__(wk
aEQ3@a
Z

|h5=J

dauthp01lp1ndassrvnintendonet
ja
__(wk
aEQ4@a
Z

|h5=])

dauthp01lp1ndassrvnintendonet

j
{{k
a(wEm@



ZEQ4@a
Z

|h5=])

dauthp01lp1ndassrvnintendonet

jN
__(wk
aEQ5@a
Z

|h5=J

dauthp01lp1ndassrvnintendonet
j
__(wk
aEQ6@a
Z

5=IQ])

dauthp01lp1ndassrvnintendonet

jG
__(wk
aEQ7@a
Z

5=

dauthp01lp1ndassrvnintendonet
jB__(wk
aEQ8@a

Z

5=IQ])

dauthp01lp1ndassrvnintendonet

j
C{{k
a(wEm@



ZEQ8@a

Z

5=IQ])

dauthp01lp1ndassrvnintendonet

jC__(wk
aEQ9@a	
Z

5=

dauthp01lp1ndassrvnintendonet
jH__(wk
aEQ:@a
Z

̭5=f])

dauthp01lp1ndassrvnintendonet

jJ__(wk
aEQ;@a
Z

̭5=G

dauthp01lp1ndassrvnintendonet

Se me ha bloqueado WebKit en la switch 2 por alguna razón. No sé si tendrá que ver con que me crasheó mucho cuando hicimos pruebas o si es que alguna de las pruebas cambió algo en el propio programa que ahora hace que al abrirlo diga "Esta función no está disponible." (no creo que sea por eso), o si es que la switch 2 misma ha bloqueado webkit (puede hacer eso?), pero ahora ya no se abre.

Lo que sí he hecho es capturar el packet que utiliza la consola al conectarse a un AP para comprobar si tiene acceso a internet usando python para enviar únicamente ese packet a Nintendo. La switch envía el packet por una interfaz WLAN conectada por USB al portatil y no se envía a ningún sitio (el portatil no transfiere internet desde otras interfaces), pero un script de python la ve y la envía manualmente por la interfaz que sí tiene internet, capturando la respuesta sin enviársela a la consola.
Sabiendo lo que se recibe que causa que la switch detecte que tiene internet (y se mantenga conectada al AP), se lo envío yo manualmente a la consola para que se mantenga conectada aun sin acceso a internet.
#!/usr/bin/env python3
"""
Responde a la Switch como el servidor real de Nintendo:
200 OK, text/plain, body 'ok', con las cabeceras exactas.
La Switch cree que hay internet y se queda conectada.
Sin forwarding ni NAT: no hay internet real.
"""
from http.server import BaseHTTPRequestHandler, HTTPServer
from datetime import datetime
import email.utils

# Respuesta exacta de Nintendo a ctest.p01.ctest.srv.nintendo.net
NINTENDO_BODY = b"ok"
NINTENDO_CTYPE = "text/plain"


class H(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def _send_nintendo(self):
        now = email.utils.formatdate(usegmt=True)
        self.send_response(200)
        self.send_header("Content-Type", NINTENDO_CTYPE)
        self.send_header("Content-Length", str(len(NINTENDO_BODY)))
        self.send_header("Expires", now)
        self.send_header("Cache-Control", "max-age=0, no-cache, no-store")
        self.send_header("Pragma", "no-cache")
        self.send_header("Date", now)
        self.send_header("Connection", "close")
        self.send_header("X-Organization", "Nintendo")
        self.end_headers()
        self.wfile.write(NINTENDO_BODY)

    def do_GET(self):
        host = self.headers.get("Host", "").split(":")[0]
        print(f"{self.client_address[0]} Host={host} GET {self.path}", flush=True)

        # Nintendo: respuesta exacta -> "hay internet"
        if "nintendo" in host or "ctest" in host:
            return self._send_nintendo()

        # Resto de dispositivos: respuesta neutra (no hay internet real)
        self.send_response(404)
        self.send_header("Content-Length", "0")
        self.end_headers()

    def do_HEAD(self):
        host = self.headers.get("Host", "").split(":")[0]
        if "nintendo" in host or "ctest" in host:
            now = email.utils.formatdate(usegmt=True)
            self.send_response(200)
            self.send_header("Content-Type", NINTENDO_CTYPE)
            self.send_header("Content-Length", str(len(NINTENDO_BODY)))
            self.send_header("Expires", now)
            self.send_header("Cache-Control", "max-age=0, no-cache, no-store")
            self.send_header("Pragma", "no-cache")
            self.send_header("Date", now)
            self.send_header("Connection", "close")
            self.send_header("X-Organization", "Nintendo")
            self.end_headers()
            return
        self.send_response(404)
        self.send_header("Content-Length", "0")
        self.end_headers()

    def log_message(self, fmt, *args):
        pass


print("Falso internet Nintendo en 0.0.0.0:80", flush=True)
HTTPServer(("0.0.0.0", 80), H).serve_forever()

Con ella conectada, puedo ver cosas que la consola envíe. Cómo puedo usar esto para intentar vulnerarla?

Tu script de "internet falso" es una pieza de infra seria — captura-replay del connectivity check con la respuesta exacta. Eso ya te da dos cosas nuevas importantes: la consola se queda conectada indefinidamente (test de conectividad satisfecho), y ahora tienes un punto de observación y manipulación del tráfico *no-web* de la consola. Antes de aprovecharlo, resolvamos el bloqueo del applet.

## El applet bloqueado: diagnóstico

Lo más probable, por orden de probabilidad:

1. **Flag de fallo del captive portal persistido.** El `WifiWebAuthApplet` guarda estado de la sesión de portal. Si el applet crashea (2168-0002) durante el proceso de login del portal, el sistema puede marcar la conexión como "portal no completado" y el siguiente intento de abrirlo se aborta antes de cargar la página. Se resuelve normalmente: borra la configuración de red problemática (Ajustes → Internet → ajustes de conexión → borra ese AP), reinicia, y vuelve a añadirla. También prueba "Conectar a Internet" desde cero en vez de reusar la entrada guardada.
2. **Estado corrupto del save data del applet** por los crashes repetidos — esto conecta con lo que vimos: estado que sobrevive a los crashes. Si borrar la red no lo arregla, un **Clear Cache** de la consola (Ajustes → Consola → Borrar caché, o la opción equivalente en S2) puede resetear el estado del applet. Cuidado: en S2 "borrar caché" es poco destructivo pero hazlo consciente.
3. **No es un "ban" de Nintendo.** Nintendo no puede bloquear el WebKit selectivamente por firmware sin update, y un update no ha pasado (seguirías en 21.1.0). No es eso.
4. "Esta función no está disponible" al abrir el applet en un AP con portal completado: la consola solo lanza el applet de portal cuando detecta un portal — con tu internet falso ya validado, **quizá ya no intenta siquiera abrir el portal**. Es decir: el bloqueo puede ser un *efecto de tu propio setup*: ahora que la consola cree que hay internet, el applet del portal nunca se dispara. Prueba: entra al AP con el servidor de ctest **apagado** (la consola detecta "hay portal") y deja que el portal abra la página — ahí empieza el ciclo y arrancas tu portal.py después.

Test diagnóstico en orden: (a) borra la red guardada y reconecta con ctest server down → ¿abre el portal? (b) si abre, conecta y arranca el falso internet, ¿sigue vivo? (c) si ni así, clear cache. Documenta qué paso lo cura — eso es una caracterización más del estado persistente del applet.

## Sobre tu man-in-the-middle selectivo: qué has construido

Lo que describes — la consola envía el connectivity check por la interfaz WLAN-USB, tú lo interceptas, lo respondes con el paquete capturado de Nintendo, y la consola queda "conectada" sin internet real — es un **half-MITM controlado**: la consola habla, tú eliges qué ve. Eso tiene valor directo:

### 1. Inventario de comunicación (lo primero, hoja de rata)

Con la consola conectada a tu setup, captura TODO durante sesiones de uso normal (Inicio, tienda intentando conectar, applet abriendo, etc.) y clasifica:

- **Hosts y DNS consultados**: lista completa de endpoints de Nintendo que la consola pide. Cada host es una superficie: ¿el applet pide recursos a CDNs? ¿el sistema pide políticas de red?
- **Cabeceras exactas** de cada petición: User-Agent por servicio (cada applet/ servicio lleva UA distinta — eso te mapea qué proceso habla sin dump), cookies, tokens.
- **Tráfico cifrado**: la mayoría del tráfico de Nintendo es HTTPS. Qué hosts van por TLS y cuáles en claro.

### 2. La jugada grande: MITM TLS

Averigua si la consola valida certificados contra una CA store fija o si acepta CAs adicionales:

- En **Switch 1** históricamente la consola traía una CA de Nintendo y validaba estrictamente, PERO la escena descubrió que varios servicios (y especialmente los applets web en ciertos contextos) usaban validación más floja, y había herramientas de MITM TLS para la escena.
- Método de prueba: genera tu CA, sirve un cert falso para `ctest.p01.ctest.srv.nintendo.net` (y para el host que pida el applet al navegar) y mira si el connectivity check sigue funcionando. Si falla la validación, la consola aborta — es binario, lo verás claro en los logs.
- Si acepta tu CA (cualquier servicio del applet), tienes **lectura y manipulación de todo lo que el applet carga**: ahora no solo sirves tu página del portal — puedes reescribir cualquier respuesta del CDN de Nintendo que el applet pida, inyectar iframes/scripts en contenido firmado legalmente, etc.

### 3. Superficie nueva: qué más habla la consola

Con el inventario del punto 1, hay tres vectores que se abren que antes no tenías:

- **Servicios de Nintendo que la consola llama con datos parseados por ella**: si la consola habla con endpoints que devuelven payloads binarios parseados por sysmodules (políticas de red, configuración, telemetría), y estás en posición de MITM (si TLS lo permite), cada parser es superficie. Es la lógica de "smuggle data to sysmodules" que te interesaba.
- **Estados de login**: los servicios de Nintendo autentican (tokens de cuenta). Si en el MITM ves tokens en cabeceras, entiendes qué endpoints son auth-relevant — no los toques todavía (romperías la sesión de la cuenta), solo mapea.
- **Comportamiento de retry**: si cortas conexiones a mitad de respuesta (el applet pide X, tú respondes parcial), muchos clientes RPC mal escritos crashean. Es fuzzing de protocolo de red del sistema, no solo del webkit — y con tu infra es directo: tu script decide qué se manda.

### 4. El flujo de trabajo recomendado ahora mismo

1. **Recupera el applet** (borrar red / clear cache / arrancar con ctest down).
2. **Tcpdump/tshark en el portátil**, sesión completa de uso, guardado a pcap para analizar offline con calma.
3. Del pcap: mapa de hosts + protocolos + UAs + qué va cifrado.
4. Test de TLS MITM con CA propia solo contra los hosts del applet (no rompas los servicios del sistema con certificados falsos — el sistema puede marcar la consola como "conectividad anómala" y complicarte la sesión).
5. Todo lo anterior se suma a tu brújula: te dice qué *puedes* manipular y qué no.

Y una nota de contexto sobre lo que has construido: ese half-MITM con replay del connectivity check es, en esencia, la infraestructura que la escena Switch 1 usa desde hace años para operaciones offline/online controladas — has reinventado a tu manera lo que herramientas como lan-play y los setup de "NAT fija" hacen. Es buena señal: ya estás operando al nivel de infra de la escena, no solo de PoCs en un navegador.

Siguiente paso sugerido: recupera el applet y arranca el inventario de tráfico (punto 1) — es la base de todo lo demás y no requiere ni debugger ni ARW.

Ahora mismo tengo este "spy.py". No quiero devolverle nada a la consola por si Nintendo manda un baneo o alguna cosa problemática o algo así.
#!/usr/bin/env python3
"""
Espía TOTAL: captura TODO lo que la Switch emite (cualquier puerto/protocolo),
lo reenvía a su destino real por la interfaz con internet, loguea la respuesta,
y NO devuelve nada a la Switch.

Requiere: python3-dnspython, root.
"""
import socket
import struct
import threading
import time
from datetime import datetime
from pathlib import Path
import dns.resolver

IFACE = "wlx2887ba77cbd6"
SWITCH_IP = "10.0.0.90"
AP_IP = "10.0.0.1"
LOG = Path("/tmp/switch_spy_all.log")

# DNS externo (no dnsmasq)
RES = dns.resolver.Resolver(configure=False)
RES.nameservers = ["1.1.1.1", "8.8.8.8"]
RES.timeout = 3
RES.lifetime = 3

# Cache de IPs reales
_ip_cache = {}
_ip_lock = threading.Lock()

def log(msg):
    line = f"[{datetime.now().strftime('%H:%M:%S.%f')[:-3]}] {msg}"
    print(line, flush=True)
    with LOG.open("a", encoding="utf-8") as f:
        f.write(line + "\n")

def resolve_real(host):
    with _ip_lock:
        if host in _ip_cache:
            return _ip_cache[host]
    try:
        ans = RES.resolve(host, "A")
        ip = str(ans[0])
    except Exception as e:
        log(f"  DNS error {host}: {e}")
        ip = None
    with _ip_lock:
        _ip_cache[host] = ip
    return ip

def printable(b, n=200):
    return "".join(chr(c) if 32 <= c < 127 else "." for c in b[:n])

# ---------- Captura raw ----------
def capture():
    s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0003))
    s.bind((IFACE, 0))
    log(f"Captura raw en {IFACE}, filtrando {SWITCH_IP}")
    while True:
        raw, _ = s.recvfrom(65535)
        if len(raw) < 14: continue
        if struct.unpack("!H", raw[12:14])[0] != 0x0800: continue
        ip = raw[14:]
        if len(ip) < 20: continue
        ihl = (ip[0] & 0x0F) * 4
        proto = ip[9]
        src = socket.inet_ntoa(ip[12:16])
        dst = socket.inet_ntoa(ip[16:20])
        if src != SWITCH_IP:  # solo lo que EMITE la Switch
            continue
        if proto == 6:  # TCP
            tcp = ip[ihl:]
            if len(tcp) < 20: continue
            sport, dport = struct.unpack("!HH", tcp[0:4])
            off = (tcp[12] >> 4) * 4
            payload = tcp[off:]
            flags = tcp[13]
            if not payload and not (flags & 0x02):
                continue
            threading.Thread(target=handle_tcp,
                             args=(src, sport, dst, dport, payload, flags),
                             daemon=True).start()
        elif proto == 17:  # UDP
            udp = ip[ihl:]
            if len(udp) < 8: continue
            sport, dport, ulen = struct.unpack("!HHH", udp[0:6])
            payload = udp[8:ulen]
            threading.Thread(target=handle_udp,
                             args=(src, sport, dst, dport, payload),
                             daemon=True).start()

# ---------- TCP ----------
def handle_tcp(src, sport, dst, dport, payload, flags):
    if flags & 0x02:  # SYN
        # Si es un SYN, intentamos conectar al destino real y loguear.
        # Necesitamos el hostname: viene del DNS previo. Lo resolvemos por IP inversa? No.
        # En su lugar: miramos si hay SNI en el payload (si lo hay, es ClientHello).
        pass
    if not payload:
        return
    # Intentar extraer SNI si es TLS ClientHello
    sni = None
    if payload and payload[0] == 0x16:
        sni = parse_sni(payload)
    host_for_log = sni or dst
    log(f"TCP {src}:{sport} -> {dst}:{dport} len={len(payload)} SNI={sni}")
    log(f"  payload: {printable(payload)}")
    # Reenviar a destino real
    target = resolve_real(sni) if sni else None
    if not target:
        # Si es la IP del AP, no reenviar
        if dst == AP_IP:
            return
        target = dst
    try:
        remote = socket.create_connection((target, dport), timeout=5)
        remote.sendall(payload)
        remote.settimeout(5)
        resp = b""
        try:
            while True:
                c = remote.recv(8192)
                if not c: break
                resp += c
                if len(resp) > 50000: break
        except socket.timeout:
            pass
        remote.close()
        log(f"  -> {target}:{dport} respuesta {len(resp)}B")
        log(f"  resp: {printable(resp, 300)}")
        log(f"  resp_hex: {resp[:200].hex()}")
    except Exception as e:
        log(f"  -> {target}:{dport} error: {e}")
    # NO se devuelve nada a la Switch

def parse_sni(data):
    try:
        if len(data) < 5 or data[0] != 0x16: return None
        pos = 5
        if data[pos] != 0x01: return None
        pos += 4 + 2 + 32
        sid_len = data[pos]; pos += 1 + sid_len
        cs_len = int.from_bytes(data[pos:pos+2], "big"); pos += 2 + cs_len
        cm_len = data[pos]; pos += 1 + cm_len
        ext_len = int.from_bytes(data[pos:pos+2], "big"); pos += 2
        end = pos + ext_len
        while pos + 4 <= end:
            et = int.from_bytes(data[pos:pos+2], "big")
            el = int.from_bytes(data[pos+2:pos+4], "big")
            pos += 4
            if et == 0x0000:
                pos += 2
                nlen = int.from_bytes(data[pos:pos+2], "big"); pos += 2
                return data[pos:pos+nlen].decode("ascii", "replace")
            pos += el
    except Exception:
        return None
    return None

# ---------- UDP ----------
def handle_udp(src, sport, dst, dport, payload):
    # DNS: puerto 53
    if dport == 53:
        # Extraer el hostname de la query
        try:
            name = parse_dns_qname(payload)
        except Exception:
            name = None
        log(f"UDP {src}:{sport} -> {dst}:{dport} (DNS) qname={name}")
        if name:
            # Resolver con 1.1.1.1 y loguear la respuesta real
            real = resolve_real(name)
            log(f"  DNS real {name} -> {real}")
            # NO devolver a la Switch
        return
    # Otros UDP
    log(f"UDP {src}:{sport} -> {dst}:{dport} len={len(payload)}")
    log(f"  payload: {printable(payload)}")
    # Reenviar a destino real
    target = dst
    if dst == AP_IP:
        return
    try:
        r = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        r.settimeout(5)
        r.sendto(payload, (target, dport))
        try:
            data, addr = r.recvfrom(65535)
            log(f"  -> {addr} respuesta {len(data)}B: {printable(data, 200)}")
        except socket.timeout:
            log(f"  -> {target}:{dport} timeout")
        r.close()
    except Exception as e:
        log(f"  -> {target}:{dport} error: {e}")

def parse_dns_qname(pkt):
    if len(pkt) < 12: return None
    pos = 12
    labels = []
    while pos < len(pkt):
        l = pkt[pos]
        if l == 0: break
        pos += 1
        labels.append(pkt[pos:pos+l].decode("ascii", "replace"))
        pos += l
    return ".".join(labels) if labels else None

if __name__ == "__main__":
    log("Espía TOTAL (todo el tráfico de la Switch, cualquier puerto)")
    log("Reenvía a destino real, NO devuelve nada a la Switch")
    capture()

Pero sinceramente, si hay una posibilidad real de que enviar packets yo mismo pueda abrir hoyos serios, quiero probarlo.

Tu precaución es correcta y te la reafirmo: no devuelvas nada *reenviado de Nintendo* sin filtro — pero **inyectar paquetes malformados hechos por ti al protocolo que la consola espera es exactamente el siguiente paso lógico de tu setup**, y es como la escena ha encontrado la mitad de los bugs de red de las consolas (Wii, 3DS, PS4: parseadores de respuestas de red en userland). Lo que tienes ahora es la mitad de un fuzzer de protocolo: ya escuchas y clasificas; falta la otra mitad, responder.

## Qué superficie es atacable por inyección de red

Lo que la consola expone a un atacante en su red no son "servicios" (nmap lo confirmó: no escucha nada relevante), sino **respuestas que parsea**. La consola *habla* y espera *respuestas*; cada parser de respuesta es superficie de ataque. Ordenadas por historial de éxito en consolas:

### 1. DNS — la superficie nº1 (históricamente la más fértil)

El parser de **respuestas DNS** corre en el módulo de resolución de Horizon (userland). La consola pregunta por `ctest.p01.ctest.srv.nintendo.net` y otros hosts; tú puedes responder lo que quieras (está consultando a tu AP/dnsmasq). En consolas anteriores, los bugs de parser DNS han dado RCE (3DS, Wii U). Fuzzing objetivo:

- Truncamientos con TC flag, nombre con compression pointers malformados (el clásico: pointer que apunta al propio packet → loops/desbordes), labels de 63 bytes exactos, label de 64+ bytes, CNAME chains infinitos (más de 8 redirects), respuestas con QDCOUNT/ANCOUNT mayores que el real, TTLs enormes/negativos, RR types raros (SIG, OPT con opciones gigantes, RR malformados), respuestas más grandes que 512/4096 bytes, EDNS0 con opciones malformadas.
- **Scapy** es la herramienta: `send(IP(dst="10.0.0.90", src="10.0.0.1")/UDP(sport=53)/DNS(...))` — responde antes que el dnsmasq real (escucha también en puerto 53 y racea, o configura dnsmasq para reenviar a tu script).

### 2. NTP — la segunda más fértil

La consola sincroniza hora contra servidores NTP (verás el paquete UDP/123 en tu captura). El parser de respuesta NTP en Horizon es superficie directa: mode/li/stratum absurdos, timestamps malformados, paquete más corto que 48 bytes, kisses of death (stratum 0 con código), leap indicator inválido. Un bug aquí puede corromper estado de sistema (la hora se usa en cripto). Barato de fuzzear y de detectar.

### 3. Respuestas HTTP en claro (ya lo tienes a medio hacer)

Tu `spy.py` ya identifica las peticiones HTTP en claro. Cada endpoint que la consola pida en HTTP (no TLS) es un parser de respuesta: fuzzear headers duplicados, Content-Length mentirosos (mayor/menor que el body, negativo, hex), chunked encoding malformado (el parser HTTP/1.1 de Horizon es propio, no WebKit), 301/302 con Location raros, respuestas gzip con cabecera corrupta (si la consola las acepta y descomprime con zlib propio — el inflate parser de Nintendo es superficie clásica), respuestas vacías, corte a mitad de headers.

### 4. Fase TLS pre-handshake

Tu parseo de SNI ya funciona — el ClientHello es lo único que llega en claro. Cuando la consola inicia TLS, tú (con dnsmasq redirigiendo la IP al portátil y terminando TCP tú mismo) puedes servir **ServerHello malformados**: extension lists que se desbordan, ciphersuite lists, session ticket enorme, alertas malformadas, ServerKeyExchange corrupto. El stack TLS de Nintendo (mbedTLS con patches propios, históricamente) es superficie, y aquí no hay cribado de la web a defender el bug: si crashea el proceso que hace TLS, es suyo.

### 5. El connectivity check como primer objetivo de fuzzing

Es el endpoint más simple y el que ya tienes "dominado": en vez de devolver el paquete capturado de Nintendo, devuélvelo **mutado**: body más largo, Content-Length mentiroso, HTTP/0.9, sin headers, dos respuestas encadenadas, cabecera HTTP gigante (16KB+ de header), `X-Organization: Nintendo` con espacios/control chars. Es fuzzing de bajo riesgo (el parseador de conectividad es pequeño) y te calibra la metodología de detección de crash para el resto.

## Cómo detectar crashes cuando inyectas

Es el problema clave: los parsers DNS/NTP corren en sysmodules, no en el applet web — si crashean, puede que **el fatal sea silencioso o el proceso se relanze** sin que veas nada. Detección en capas:

1. **El applet vivo como canario**: deja tu página con heartbeat corriendo en el applet; si el sistema tiene un fatal (pantalla), lo verás; si solo se relanza un sysmodule, el heartbeat sigue — necesitas además una señal de "sistema sano": el propio connectivity check periódico de la consola (si la consola sigue enviando checks, el stack de red sigue vivo).
2. **Log correlacionado**: cada paquete inyectado va con timestamp y nonce al log; si la consola muere/reinicia, el último nonce te dice qué paquete fue. Ya tienes esa infraestructura en `log()`.
3. **Wi-Fi como indicador**: si el parser DNS crashea, la consola suele caer la conexión o reintentar DNS — monitorea la estabilidad de la asociación.

## Modificaciones concretas a tu script

Tu `spy.py` actual reenvía el payload original a los servidores reales — eso es para *observar*, y está bien. Para inyectar, añade un segundo módulo:

```python
# inject_dns.py — esbozo
from scapy.all import IP, UDP, DNS, DNSRR, send, sniff
import random

SWITCH = "10.0.0.90"

def dns_response_mutator(query_pkt):
    # genera N variantes malformadas de la respuesta al query
    resp = IP(dst=SWITCH, src="10.0.0.1")/UDP(dport=query_pkt[UDP].sport, sport=53)
    yield resp/DNS(id=query_pkt[DNS].id, qr=1, aa=1, qd=1, an=1,
                   qname=query_pkt[DNS].qd.qname)  # base
    # ...mutaciones: pointers, counts, labels, truncado...

def on_query(pkt):
    if pkt[DNS].qd:
        for r in dns_response_mutator(pkt):
            send(r)  # racea contra dnsmasq: responde primero

sniff(filter=f"src host {SWITCH} and udp port 53", prn=on_query)
```

Y para asegurar que tu respuesta llega antes que la del dnsmasq real: o rediriges el puerto 53 a tu script (iptables REDIRECT en el AP), o respondes desde un socket bind al puerto 53 con prioridad, o apuntas el DHCP a tu IP como único resolver y *tú* decides (mejor opción: dnsmasq fuera de la ecuación para DNS fuzzing — tu script contesta todo).

## Estrategia de cobertura con presupuesto

Con los recursos que tienes (iteración lenta, crash = reinicio manual), haz como en el WebKit: **fuzzing semi-manual con batches curados**, no ciego:

- Fase 1: reproducir conectividad normal con tus respuestas (baseline: consola conecta, DNS resuelve real, hora sincroniza). Sin baseline, no distingues bug de mala respuesta.
- Fase 2: batches de mutación DNS (50-100 respuestas por sesión, una a una con espera), con canario activo.
- Fase 3: NTP igual (más corto, 20-30 variantes).
- Fase 4: HTTP connectivity check mutado.
- Fase 5 (si TLS MITM resulta posible tras el test de CA): TLS handshake fuzzing.

Y guarda cada lote inyectado con su nonce — si un día consigues CFW en la S2, los creports de esos crashes (si los hubo) estarán en el NAND esperando la correlación con tu log.

Sobre tu última frase: sí, la inyección de paquetes es donde puede estar un agujero serio — es exactamente la superficie que la escena explotó en generaciones anteriores (Nintendo ha tenido parser DNS, NTP y HTTP propios en todas sus consolas). Tu infra actual (escucha + replay + inventario) es el 80% del trabajo; falta el 20% que es el injector con mutaciones y la detección de crash en sysmodules. Empieza por DNS con scapy — es la superficie con mejor historial y la más barata de probar.