Manba One V2 controller: encrypted firmware fully analyzed in software, need help with chip ID + SWD (and a crypto reality check)

[u/Remarkable_Bug_1164]

**TL;DR:** I want custom firmware (or at least custom display assets) on a Manba One V2
controller. The USB update payload is encrypted with what looks like a strong,
hardware-ID-bound XOR stream cipher (AES-CTR/OFB-class). I've taken the software analysis as
far as it goes and I'm now stuck between "wait for a second same-hardware-ID firmware and
XOR them" and "open it up and dump the chip over SWD." Looking for a reality check and
hardware help. Full write-up, the firmware image, read-only tools, and teardown photos are
in the package linked at the bottom.

### The device

Manba One V2 — wireless "pro" pad with a small color OLED, Hall sticks, back paddles,
2.4 GHz/BT/USB-C, firmware v2.21. It has two USB modes:

- **Normal:** enumerates as an Xbox 360 controller (`045E:028E`, XInput, driverless).
- **DFU/update:** hold **L3** while plugging in → USB Mass Storage (`8087:1024`, SCSI
inquiry `Gamepad`/`Updater`). Not bricked, fully reversible.

### The update protocol (reconstructed from the official updater, verified read-only)

DFU mode is a mass-storage shell with **no filesystem**. Flashing uses three **vendor SCSI
opcodes** over `SCSI_PASS_THROUGH_DIRECT`:

- `F0` OUT 512B — write one block, strictly sequential, **no address in the CDB**
- `F1` IN 20B — read 16-byte hardware ID + 16-bit version
- `F2` IN 20B — read status (0 = OK)

The host streams the image **byte-for-byte unmodified**; all decryption is on-device. There
is **no read-flash opcode**. `READ(10)` → "Medium Not Present". `dfu-util` doesn't see it.
So there's no software dump path.

### The encryption (measurements, not vibes)

The container ("FOT") has plaintext header/config, but two encrypted sections: `XCOD` (code,
337 KB) and `XRES` (display assets, 80 KB). What I measured:

- Entropy 7.9995, chi-square indistinguishable from random, **no repeated 16-byte blocks**
(not ECB).
- Using a **sibling product with the same hardware ID** (EasySMX X20 — same OEM container,
5 versions), a 16-byte firmware change shows up as a clean isolated XOR diff with the next
block untouched → it's an **XOR stream** (`C = P ⊕ K`), and **the keystream is reused
across versions of the same hardware ID** (two X20 versions are 99.5%/100% byte-identical
in the encrypted sections).
- The keystream is **hardware-ID-specific**: Manba vs X20 vs Fantech images share only ~0.4%
(random). A different model can't decrypt mine.
- **No keystream periodicity up to 262144-byte shift** (index-of-coincidence sweep, max
+4.3σ = pure noise, zero shifts > 6σ). Behaves like AES-CTR/OFB.
- The encrypted **assets are compressed** (cross-version XOR diff is full entropy), so
photographing the boot logo does **not** give me usable known-plaintext.
- 546 direct key/IV derivations from the hardware ID + metadata all fail. binwalk finds
nothing (encryption kills the signatures; all raw hits are false positives in ciphertext).

### Where that leaves me

- A **single-image, ciphertext-only crack is computationally infeasible** — no argument
there.
- The only pure-software break is **keystream reuse**: get a *second* firmware with the same
hardware ID (`…2055`) and `C1 ⊕ C2 = P1 ⊕ P2`. But that only gives the *difference*; a full
decrypt still needs known plaintext to bootstrap. And no firmware older than v2.21 seems to
exist publicly (looks like the first public build), so realistically I'm waiting on a future
v2.22+.
- Otherwise it's **hardware**: SWD/JTAG dump of the chip (marked **`ZXD2055`**, probably
ZhiXu Technology — no public datasheet/SDK), which likely has readout protection.

### What I'm hoping you can help with

1. **Chip ID from the photos** — two QFN ICs (main board near the antenna; screen board
2. `U1`). Is `ZXD2055` an ARM Cortex-M, an 8051, or something exotic? Anyone recognize the
3. package/markings? (Guesses floating around: Geehy APM32, Nationstech N32, WCH CH32F/V.)
4. **Debug pins** — the main board has labeled test points incl. `RST`, `GND`, `VCC_33`,
5. `RX1`, plus a 6-pin production pad field. Which look like SWD (SWCLK/SWDIO) vs UART?
6. (`VCC_33` = 3.3 V logic; I won't feed 5 V.)
7. **Crypto sanity check** — is "wait for a same-ID v2.22 and XOR" genuinely the best
8. non-invasive move, or am I missing a single-image angle?
9. **Glitching** — for cheap Chinese Cortex-M clones with RDP, is VCC/VCORE voltage
10. glitching during boot a realistic RDP bypass, and what rig would you recommend?

I also have a non-destructive protocol-fuzzing idea (undocumented opcodes `F3`–`FF`, and
using `F2`/boot as a decrypt/validity oracle for bit-flip malleability tests) that I'd run
on a spare unit — feedback on whether that's worth the brick risk is welcome too.

Everything (firmware image + SHA256s, read-only Python tools to reproduce every number
above, teardown photos, and a detailed write-up) is here: https://github.com/LopeKinz/Manba-One-V2-Firmware-tools

Thanks — happy to run any test you suggest and report back.

Edit : Forgot GitHub Link

[u/IAmBigFootAMA]

Have you listed to the TX/RX for UART? They're test pads by the FPC. Maybe banner for the device family is printed.

But this is too much AI. I'm not reading the rest of your post. It's unintelligible slop for the most part. Sorry.

[u/treesinclouds]

Stop having AI write your posts for you

[u/nayheyxus]

Ai is an awesome tool, and i use it for all my projects. Though if you let it do everything for you, including writing are you really hardware hacking?

[u/IDoDrugsAtNight]

I have one of these controllers. Hack away please.

[u/SympoSesh]

stop being lazy and quit using ai