Skip to content

Beta v0.1.0

Choose a tag to compare

@PabloSoage PabloSoage released this 14 Sep 20:52
· 47 commits to main since this release

opendash 0.1.0 — a Scanmatik SM3 over Wi-Fi, a GM parameter catalogue, and an ELM327 bridge

Context: first release. A proprietary Wi-Fi diagnostic adapter with no public
protocol, an Android app that speaks it, and the parameter catalogues of the
manufacturer's own tool. Fifteen days, 31 August to 14 September 2026, across three
repositories: opendash (the app, GPL-3.0, public), opendash-plugins (the
catalogues, private) and scanmatik-bench (the reverse-engineering bench, private).

Method: empirical throughout. The protocol was taken from packet captures of the
factory tool and then confirmed against a physical vehicle — an Opel Astra J 1.7 CDTI
(A17DTJ, Denso ECU) — over three sessions at the car. Nothing in section 3
is inferred from a capture alone unless it says so. Where a thing is believed rather
than measured, section 7 says which.

Deliverable: android-arm64-v8a-release.apk, minSdk 26, three languages
(en/es/de). 47 Kotlin files, 7 Rust files, 17 core tests.


1. What it is

A diagnostic application for Android that talks to a Scanmatik SM3 over the
adapter's own Wi-Fi access point, and turns it into three things:

  1. a live data screen driven by the manufacturer's own parameter catalogue, able
    to read a module's own identifiers rather than the twenty-odd standard OBD PIDs;
  2. an ELM327 bridge — a TCP server the phone runs, so any existing OBD app can use
    an adapter that speaks nothing it has ever heard of;
  3. a recorder, writing gzipped CSV as the session happens.

The adapter is not an ELM327 and does not pretend to be. It is a J2534 pass-through
with a proprietary TCP protocol; the whole of section 3 is what had to be established
before any of the above could exist.


2. Change catalogue

ID Area Item Type
P1 Protocol 16-byte frame header, wire stride align(16+len, 4) feature
P2 Protocol h4 identified as a CRC, reflected polynomial 0x9960034C feature
P3 Protocol h8 = sum of the padded data as little-endian words feature
P4 Protocol Both signatures closed for any length, so messages can be constructed feature
P5 Protocol Opcode map: greeting, open, session, config, channel, status, control, voltages, bus, pushed frames feature
P6 Protocol Channel block with real filters, built and signed by us, accepted by the adapter feature
G1 GMLAN This bus is GMLAN, not UDS: TesterPresent is a bare 3E, no sub-function fix
G2 GMLAN A module answering on 0x64X emits on 0x54X; the engine answers 0x7E8 and emits 0x5E8 fix
G3 GMLAN The eight bytes of a bus write are the CAN frame itself, not a length and seven fix
G4 GMLAN Identification block: 1A 90 VIN, 92 supplier, 97 engine type, 98 subscriber, 99 date, B4 traceability feature
S1 Streaming 2C <dpid> <id16>… declares a packet, max 2 identifiers; 6C acknowledges feature
S2 Streaming AA 04 <dpid>… starts up to 5 packets at once, AA 00 stops feature
S3 Streaming ~101 frames per second per packet, measured feature
S4 Streaming The module stops emitting after ~5 s without a 3E; the stream needs a heartbeat fix
A1 App Link screen: joins the adapter's Wi-Fi, opens the channel, shows battery feature
A2 App Identification: module sweep and the 1A block, per module feature
A3 App Live data: catalogue by module and variant, search, selection, charts feature
A4 App "Ask this car": probes the catalogue with 0x22 and remembers what answered, per VIN feature
A5 App Fast mode: declares packets and reads the module's own emission feature
A6 App Health: fault codes and EOBD readiness monitors feature
A7 App Recordings: gzipped CSV, and a viewer for Scanmatik's own .sm2 feature
A8 App ELM327 bridge as a foreground service, so it survives a locked screen feature
A9 App Plugin catalogues: install, browse, fetch over SFTP feature
C1 Catalogue A catalogue key names a concept; a row is identified by name, id, width, formula and unit fix
C2 Catalogue Variants carry the module they belong to, and modules carry a CAN address feature
R1 Research The GDS2 vehicle database (vatbin.bin, 89 MB) read with the format its own loader declares feature

3. The protocol, as established

3.1 The frame

The adapter is a plain TCP server on 192.168.81.1:777 once the phone has joined its
access point, which is named DIRECT-SCANMATIK-#<serial>. Every message is a 16-byte
header followed by data:

seq u16 | token u16 | h4 u32 | h8 u32 | op u8 | len u16 | chk u8

and the next message begins at align(16 + len, 4).

chk is a one-byte checksum over the opcode and length. The two long words are the
part that mattered: without them the adapter closes the connection on the first
malformed message, which from the outside is indistinguishable from a broken socket.

  • h8 is the sum of the data as little-endian 32-bit words — including the
    padding
    , which is not zero. A block of 305 data bytes ends in 1e a1 f1, and
    zeroing it changes the signature.
  • h4 is a CRC with reflected polynomial 0x9960034C. It was first fitted as an
    affine function of the payload, which worked for one shape of message and silently
    failed for others; identifying the polynomial closed it properly. The chain for a
    message of arbitrary length is anchored at the last bit of the padded data,
    which is what allows a message of any size to be signed rather than only replayed.

Being able to construct messages rather than replay captured ones is what made
everything after this possible.

3.2 The channel

Opening the bus is a 0x50 message: the speed as a u32 at data+134, the filter count at
142, and 59-byte filter records from 305. A filter is a mask, a pattern, and a type —
pass, block, or flow control.

The app used to open the channel with a single PASS mask=0 pattern=0, which is "send
me everything". Measured against the factory tool:

GDS2        9 addresses,  99.6 % of it the emission it asked for
the app    51 addresses,  1 340 frames/s,  173 decoy frames/s

Those 173 frames a second are what made the app lose races against its own answers.
The release builds a channel with four pass filters — 0x7E8..0x7EF, 0x640..0x65F,
0x540..0x55F, 0x5E8 — signs it, and the adapter accepts it. Verified at the car on
14 September: with the filters in place the frame rate drops to nothing while idle and
the VIN still reads whole through it.

3.3 The bus is GMLAN

Three assumptions carried over from UDS cost a day each.

  • TesterPresent has no sub-function. 3E 00 is answered 7F 3E 12, sub-function
    not supported. It is a bare 3E.
  • A module emits on a different address from the one it answers on. Module 0x24X
    answers on 0x64X and emits on 0x54X; the engine answers on 0x7E8 and emits on
    0x5E8. Streaming looked completely dead until this was found — the frames were
    arriving the whole time, on an address nothing was listening to.
  • A write carries the CAN frame, not a payload. The eight bytes of a bus write are
    the frame itself. Sending flow control as 08 30 00 — a length byte and the frame —
    meant multi-frame answers never continued, and the VIN came back as its first four
    characters.

3.4 Streaming

The factory tool does not poll. It declares a packet with 2C, naming the identifiers
and their order, and tells the module to emit it with AA 04. Measured over one
factory session: 480 requests from the tester against 167 447 frames pushed back,
across seven packets.

Both commands travel as ISO-TP single frames, which carry seven bytes. That caps a
declaration at two identifiers and a start command at five packets — a limit learned
the hard way, from a payload that went out with a PCI byte promising nine bytes and
seven behind it.

A module told to emit then hears nothing more from the tester, so it drops the session
and stops sending after about five seconds. The stream has to be held open with a 3E
every two seconds, exactly like a sweep.


4. The app

Link. Joins the adapter's access point from inside the app, so mobile data can stay
on and the socket is pinned to the right network. Opens the channel, polls the battery
off the adapter rather than the bus.

Identification. Sweeps for modules that answer, then reads the 1A block from each
one. The VIN answered consistently from eight different modules on the test vehicle.

Live data. The catalogue is chosen by module first and variant second. A marque
catalogue is every configuration the manufacturer ever shipped — 21 381 parameters for
Opel across 221 variants — and offered flat it is not a list, it is a reason to close
the screen. Grouped by module it is a dozen readable names, with the ones this car
answered on first.

Ask this car. The catalogue cannot say which configuration is parked outside: the
GDS2 packages carry no model-to-variant table. So the module is asked. The probe walks
every identifier the module's catalogue names, keeps what answers, and stores it
against the VIN. On the test vehicle: 2 638 identifiers asked, 204 rows kept of the
engine's 5 249 — a 96 % cut, and it agrees with what the factory tool's own session log
says this car is.

Fast mode. Declares packets and reads the module's own emission, at about a hundred
frames a second against the four or five a second that polling shares between
everything selected.

Bridge. A TCP server on 127.0.0.1:35000 by default, speaking ELM327. Runs as a
foreground service, because a plain thread is killed within minutes of the screen going
off and a session is spent with the phone in a pocket.

Recordings. Gzipped CSV, flushed per row so an interrupted session is short rather
than corrupt. Measured over a 23-minute drive, 79 796 readings: plain CSV 3.63 MB,
Scanmatik's own binary 0.98 MB, gzipped CSV 0.60 MB.


5. Catalogues

Extracted from GDS2 deliverable packages and shipped as plugins, three languages each:

Plugin Parameters Variant rows Modules
gm-global 66 834 152 979 1 945
gm-china 47 141 92 261 1 049
opel-vauxhall 21 381 34 148 720
saab 4 443 9 001 110
vinfast 2 608 2 858 25

A key names a quantity, not a row. 2 859 of Opel's 11 480 keys carry more than one
distinct parameter: key 8483_6763 is twenty-eight different "Vehicle Speed" rows,
each with its own identifier and scaling. This was originally read with an
associateBy, which keeps one row per key and drops the rest without a word — not a
smaller list, an arbitrary one, and the surviving row could carry the width of a
configuration this car does not have.

Choosing the right variant does not resolve this: a variant names keys, and one key
carries all the rows. The only discriminator is which identifier the car answers.


6. Verified against a vehicle

Three sessions at the car, 4, 6 and 14 September 2026, contact on, engine off and
running.

Adapter greeting, serial and firmware ✅
Battery voltage off the adapter ✅ 12.1 V
Channel open, and the constructed filtered channel ✅
1A identification block, eight modules ✅
Mode 01 PID enumeration and decode ✅ 21 live
Service 0x22 against the catalogue ✅ 2 638 probed
Streaming: declare, start, decode, stop ✅ ~101 Hz
ELM327 bridge, end to end against the car ✅ from the bench
Odometer, checked against the dashboard ✅
Recording, 3 944 rows over a running engine ✅

The ELM327 transcript, against the car, from the desktop reimplementation of the app's
own bridge:

ATZ    -> ELM327 v1.5          ATRV  -> 12.3V
0100   -> 7E8 06 41 00 98 3B 20 13
010C   -> 41 0C 00 00          (engine stopped)
0105   -> 41 05 52             = 42 °C
0902   -> VIN, three frames    1A90 -> VIN, GM service

7. What is not verified

Said with the same insistence as the rest, because it matters as much.

  • The bridge from the phone. The protocol half is proven against the car; that the
    foreground service starts and an OBD app reaches the socket is not. There is a
    Test button on the Link screen for exactly this — it connects to the bridge the
    way an external app would and shows what came back.
  • Automatic variant selection. The app cannot yet pick a module's configuration on
    its own. See section 8.
  • 0x9A as the identifier behind the factory tool's attribute checks. A prediction,
    not a measurement — see section 8.
  • Anything that writes. Nothing in this release writes to a module. Every service
    it sends is a read, and the client refuses to send anything else.

8. Research that has not landed in the app yet

The factory tool decides which configuration a module is by evaluating conditions
written in a small language found in its vehicle database:

BCD(<attribute>,<value>,<operator>)     compares a resolved attribute
ECU_ID_<module>_CHECK=<0x…>             compares a module's DDI
DDI_VALUE <op> <n>                      the DDI just read

joined with && and ||. The attributes are read from the bus, not asked of the
user
: 19 descriptions of the form "Read the DDI from …" and a prompt type that says
"System will Resolve Option Type".

The database format was not guessed. RTKApplet.jar decompiles to the class that opens
vatbin.bin, and it gives the header, the 44-byte option nodes, their attribute
tables, and the twelve-byte link table that attaches shared subtrees and binds a node
to one of the 21 machines. Following those links takes the option tree from 2 962 nodes
to 10 487. String pointers inside a machine's value records are stored as
doubles
, which is why searching 89 MB for 32-bit references to a condition string
finds nothing at all.

With that, this car's two candidate engine modules each hang off their own node with
their own condition, and the one the factory tool rejected requires
BCD(Transmission Type,Automatic,=) — the car is manual.

Still open: which identifier each ECU_ID_*_CHECK actually requests. The method
carries a name, a mask and a description, not an identifier; the catalogue has a
parameter called exactly Diagnostic Data Identifier, 0x9A, two bytes, and the values
the conditions compare against are two-byte quantities. It fits. It is not proven, and
it is testable at the car in one request.


9. Building

./gradlew :android:assembleRelease      # APK, arm64-v8a and x86_64
cargo test --manifest-path core/Cargo.toml

The Rust core cross-compiles with the NDK and cargo-ndk; CI builds without it
(-Popendash.rust=false), since nothing loads the library yet — there is no JNI bridge
and the core is tested on the host by its own job.


10. Credits and licence

GPL-3.0. The app contains no manufacturer data: the catalogues live in a separate
plugin repository, and the application only knows how to read them.