Lettura e scrittura di una cremagliera EPS BMW via FlexRay
Un piccolo agent per l’MPC5643L che gira direttamente nella cremagliera: legge e scrive la flash e la EEPROM della cremagliera via FlexRay — niente JTAG, niente apertura della scatola.
Appunti dal banco, dal lato riparazione. Tutto quanto descritto è stato fatto su unità smontate, sul mio banco di prova, come attività di rigenerazione/diagnostica, ed è tutto uscito dal firmware: immagine aperta in Ghidra e disassemblata, verificata rispetto ai miei dump e a una grande quantità di testo in chiaro noto. Lascio fuori l’accesso di sicurezza (security access) dell’OEM: non è mio da pubblicare e, in ogni caso, nell’agent non c’è.
In breve
La centralina dello sterzo su una buona fetta della gamma BMW Serie F (tag interno del loader 000019EE, d’ora in poi «19EE») è costruita attorno a un NXP MPC5643L — un PowerPC dual-core in lockstep con set di istruzioni VLE — con la calibrazione suddivisa tra la flash C90FL on-chip e una SPI EEPROM M95640 esterna. La strumentazione di fabbrica ci dialoga via FlexRay.
Volevo leggere e scrivere entrambe le memorie al banco, via FlexRay, senza appendere una sonda JTAG a ogni singola unità. La via è stata un minuscolo agent autonomo, caricato nella SRAM della cremagliera via FlexRay tramite un percorso di upload che ho estratto dal firmware in Ghidra, che risponde alle operazioni di memoria verso il mio cavo. Questo articolo illustra l’agent: la logica FlexRay, i driver EEPROM e flash e un trucco di protocollo che ha risolto una lettura instabile.

il banco. L’unità MS561 per EPS (alimentazione e diagnostica), il cavo FlexRay, una cremagliera 19EE, il ThinkPad con MS561 in esecuzione e l’oscilloscopio in alto.
L’obiettivo
L’MPC5643L è un MCU orientato alla sicurezza: due core e200z4 in lockstep, ECC ovunque e un controller FlexRay E-Ray Freescale/NXP integrato sul die. I numeri che contano per il resto dell’articolo:
| Cosa | Dove |
|---|---|
| Core | e200z4, PowerPC VLE (lunghezza variabile), big-endian |
| Flash codice | controller C90FL all’indirizzo 0xC3F88000, flash mappata alla base 0x0 |
| «block0» | 0x0000–0x3FFF (16 KB) — calibrazione + un CRC-32 di configurazione |
| EEPROM | M95640 esterna (64 Kbit SPI) su DSPI_B all’indirizzo 0xFFF94000 |
| FlexRay | CC E-Ray NXP all’indirizzo 0xFFFE0000, message RAM nella SRAM di sistema |
Un’insidia VLE subito: la maggior parte delle build standard di objdump non decodifica il VLE — un binutils del 2005 produce spazzatura. Il lavoro statico l’ho fatto in Ghidra con il linguaggio PowerPC:BE:64:VLE-32addr. Sbaglia la modalità e l’intera immagine si decodifica in nonsenso.

il chip. Il die principale della cremagliera — SPC5643LFMLQ1, l’MPC5643L — con la piccola SPI EEPROM M95640 a 8 pin alla sua sinistra.
Perché un agent e non «semplicemente JTAG su tutto»
Per molto tempo l’unica via a questi dati è stata la chirurgia a forza bruta: aprire l’involucro della centralina, dissaldare la EEPROM, leggerla e riprogrammarla su un programmatore esterno economico e poi risaldarla. Funziona — molte officine lo fanno ancora — ma è lento e laborioso, e ogni andata e ritorno è un’altra occasione per sollevare una piazzola o cuocere il chip. Il JTAG è più pulito ed è ciò che ho usato in fase di reverse engineering, ma significa comunque aprire quella scatola sigillata per raggiungere le piazzole di debug. Nessuna delle due è cosa che si vuole ripetere unità dopo unità al banco.

fase RE. Come la leggevo durante il reverse engineering: scatola aperta, un programmatore JTAG P&E sul connettore di debug della cremagliera. Va bene per il laboratorio, non è cosa da fare su ogni unità.
L’agent evita tutto questo. Entra via FlexRay — il bus già presente sul connettore — così l’unità resta chiusa: niente scatola da aprire, niente chip da dissaldare, niente piazzole da sollevare.
Scavando nel firmware in Ghidra ho trovato il meccanismo già lì: un percorso nel loader che tira un piccolo programma nella SRAM libera della cremagliera via FlexRay e lo esegue. Ho quindi scritto il mio agent per quel percorso, il cui compito è semplicemente:
interrogare uno slot FlexRay per i comandi, eseguire l’operazione di memoria, rispondere su un altro slot.
Niente libc, niente RTOS, nessuna dipendenza. Ottiene stack pointer ed entry point dal loader, emette una firma di «vita» così posso confermare che è il mio codice a girare, poi resta in un loop di comandi.
Passo uno: sbloccare la modalità engineering
Prima che tutto questo funzioni, la cremagliera va messa nella sua modalità engineering, protetta dall’accesso di sicurezza UDS (security access). La sequenza è un normale UDS:
- DiagnosticSessionControl nella sessione estesa (
10 03), poi nella sessione engineering (10 42). - SecurityAccess — il livello «13/14»: richiedere il seed (
27 13) e la cremagliera restituisce un seed da 8 byte; calcolare la risposta; inviare la chiave (27 14). La chiave è un campo lunghezza da 4 byte seguito da una firma da 128 byte. - RoutineControl Start (
31 01 03 0C) — è questo ad armare la modalità engineering. Ho individuato la routine 030C in Ghidra; il suo dispatcher RoutineControl è all’indirizzo0x635a0.
L’unica parte che tengo per me è il passo centrale: come viene prodotta quella firma e la chiave che vi sta dietro. Questo resta sul mio banco. Come la cucina BMW? Andate a chiederlo a loro. 😉
Passo due: portare l’agent sul chip
Nel firmware c’è un loader che prende un blocco di codice nella SRAM libera via FlexRay e lo esegue. L’ho smontato in Ghidra:
- Un comando SETUP (
00 03) mette il task di ricezione del loader (un task RTOS; dispatcher all’indirizzo0x80000, tabella degli handler all’indirizzo0x40009098) in modalità ricezione; la cremagliera risponde con un ack (00 08 51). - Il ricevitore di frame all’indirizzo
0x8c664copia i dati in arrivo nella SRAM solo se un gate di stato all’indirizzo0x7e40è armato a0xFE/0xFF. Altrimenti ogni frame viene scartato silenziosamente. - Ad armare quel gate è l’ingresso engineering stesso: la sessione UDS imposta un byte di stato (
0x7944) a1, RoutineControl030Cesegue il suo handler, e la routine di ingresso engineering all’indirizzo0x81010scrive0x7e40 = 0xFEe avvia il task.
L’insidia che mi è costata tempo: il SETUP viene accettato, l’ack torna, ma il burst comunque non «atterra». Un dump della RAM della cremagliera (ICDPPCNEXUS Hotsync, senza reset) mostrava 0x7e40 = 0 — il task di ricezione non era armato, quindi ogni frame veniva abbandonato. Inviare più in fretta non aiuta: il ricevitore deve essere armato e restare armato quando arriva lo stream, quindi l’ordine è: armare 030C, attendere che il cluster FlexRay salga, poi inviare il burst. Con il gate mantenuto, il codice atterra nella SRAM, parte e l’agent si annuncia col suo frame di vita (00 4C 8A A0 A1 … BF). Niente JTAG, scatola chiusa.
FlexRay, come lo vede l’E-Ray
Tutto passa per due message buffer FlexRay (MB): l’agent ascolta su uno e risponde sull’altro. La message RAM dell’E-Ray è un array di header più una regione dati, e la configurazione di un buffer sta nei registri all’indirizzo ERAY_BASE + 0x100 + idx*8.

sul filo. Il cavo che sniffa la linea FlexRay RX della cremagliera mentre mettevo a punto il framing — qui in registrazione dal vivo a ~580 000 fronti/s con clock di campionamento a 275 MHz.
eng_agent.c — mappa dei message buffer dell’E-Ray
#define ERAY_BASE 0xFFFE0000u /* E-Ray CC; MVR @ +0 reads 0xA268 */
#define FR_MEMBASE 0x40002A00u /* message RAM base = SYMBADHR:SYMBADLR */
#define MBCCSR(i) (*(volatile u16 *)(ERAY_BASE + 0x100u + (u32)(i)*8u + 0u))
#define MBCCFR(i) (*(volatile u16 *)(ERAY_BASE + 0x100u + (u32)(i)*8u + 2u))
#define MBFIDR(i) (*(volatile u16 *)(ERAY_BASE + 0x100u + (u32)(i)*8u + 4u))
#define MBIDXR(i) (*(volatile u16 *)(ERAY_BASE + 0x100u + (u32)(i)*8u + 6u))
#define MEM16(off) (*(volatile u16 *)(FR_MEMBASE + (u32)(off)*2u))
/* MBCCSR bits */
#define MB_MTD 0x1000u /* transmit direction */
#define MB_CMT 0x0800u /* commit (TX) */
#define MB_LCKT 0x0200u /* lock toggle */
#define MB_DVAL 0x0008u /* data valid (RX) */
#define MB_LCKS 0x0002u /* locked status */
#define MB_MBIF 0x0001u /* interrupt flag */
#define RX_MB 2u /* I listen on slot 3 (frameID 3 = MB index 2) */
#define TX_MB 0u /* I answer on slot 1 (frameID 1 = MB index 0) */
#define KEEP 0xF900u /* config bits I must preserve on every CSR write */
Per toccare un buffer lo si blocca (commutare LCKT, confermare che LCKS sia tornato impostato). La cosa che mi ha morso qui:
Il MB di trasmissione ritrasmette via hardware il proprio contenuto a ogni ciclo FlexRay. Mentre il controller copia il buffer sul bus ne possiede il lock, e un singolo tentativo «commuta e spera» perde la corsa più spesso di quanto vorresti.
Il lock ingenuo a colpo singolo restituisce silenziosamente «non preso», la risposta non parte mai, l’estremità remota vede il blocco ammutolire e la lettura si tronca o rallenta mentre l’altra parte continua a richiedere. La soluzione è ciclare finché il controller non cede il buffer: c’è una finestra libera a ogni ciclo. Riprovare è sicuro: una scrittura LCKT rifiutata viene semplicemente ignorata (stato invariato), quindi non puoi corrompere nulla, e ti fermi nell’istante in cui LCKS si rilegge impostato, così non togli mai un lock che già possiedi.
mb_lock — cicla finché il CC non cede il buffer
/* Lock a MB. Return 1 if locked, 0 if the CC never yielded it.
The TX MB retransmits every cycle and the CC owns it while copying out,
so a single LCKT write often loses the race. Spin until a free window. */
static int mb_lock(u32 i)
{
u32 spin;
for (spin = 0; spin < 200000u; spin++) {
MBCCSR(i) = (u16)((MBCCSR(i) & KEEP) | MB_LCKT);
if (MBCCSR(i) & MB_LCKS) return 1;
}
return 0;
}
static void mb_unlock(u32 i) { MBCCSR(i) = (u16)((MBCCSR(i) & KEEP) | MB_LCKT); }
static void mb_clrflag(u32 i) { MBCCSR(i) = (u16)((MBCCSR(i) & KEEP) | MB_MBIF); }
Interrogare un comando è quindi: bloccare, controllare DVAL (frame nuovo?), leggere l’header per trovare dove sta il payload e quanto è lungo, copiarlo fuori, sbloccare. Inviare una risposta è l’immagine speculare.
rx_poll / tx_send — un comando in ingresso, una risposta in uscita
/* Poll the RX slot. On a new frame copy up to maxw words into dst, return #words. */
static int rx_poll(u16 *dst, int maxw)
{
u16 idx, hdr, dataoff, len, p;
if (!mb_lock(RX_MB)) return 0;
if (!(MBCCSR(RX_MB) & MB_DVAL)) { mb_unlock(RX_MB); return 0; }
mb_clrflag(RX_MB);
idx = MBIDXR(RX_MB);
hdr = (u16)(idx * 5u); /* header = idx*5 halfwords */
dataoff = (u16)(MEM16(hdr + 3) / 2u); /* header[3] = data byte offset */
len = (u16)(MEM16(hdr + 1) & 0x7Fu); /* header[1] low 7 bits = words */
if (len > maxw) len = (u16)maxw;
for (p = 0; p < len; p++) dst[p] = MEM16(dataoff + p);
mb_unlock(RX_MB);
return (int)len;
}
/* Write the response words into the TX slot and commit. */
static void tx_send(const u16 *src, int words)
{
u16 idx, hdr, dataoff; int p;
if (!mb_lock(TX_MB)) return; /* CC busy: skip; the far side re-asks (robust) */
mb_clrflag(TX_MB);
idx = MBIDXR(TX_MB);
hdr = (u16)(idx * 5u);
dataoff = (u16)(MEM16(hdr + 3) / 2u);
for (p = 0; p < words; p++) MEM16(dataoff + p) = src[p];
MBCCSR(TX_MB) = (u16)((MBCCSR(TX_MB) & KEEP) | MB_CMT); /* commit */
mb_unlock(TX_MB);
mb_clrflag(TX_MB);
}
Il trucco che ha reso affidabili le letture: eco nella risposta
Quel comportamento «ritrasmette a ogni ciclo» ha una seconda conseguenza. Poiché il buffer TX continua a mettere sul bus il suo ultimo contenuto, il ricevitore può agganciare una copia vecchia della risposta precedente — specie alla prima lettura dopo un cambio di stato: finisci una richiesta indietro, chiedi l’indirizzo N e ottieni i byte per N-1, e sembra quasi giusto finché non lo è per niente.
Ritardi di assestamento e ritentativi lo mascherano, ma sono una corsa e sono lenti. La soluzione deterministica è rendere ogni risposta auto-identificante. L’agent imprime due parole in più nel frame: un token di eco (l’indirizzo richiesto, o un sentinella fisso per una scrittura) e una magic di risposta. Il cavo rifiuta allora qualsiasi risposta il cui eco non corrisponda alla richiesta appena inviata. Niente timing, niente congetture — il frame sbagliato viene rifiutato strutturalmente.
build_response — frame di risposta + timbro di eco
#define REPLY_MAGIC 0x4321u /* "this is a real data reply" tag */
#define WRPOS_ECHO 0x5A5Au /* sentinel for the destructive write reply */
/* Build "00 4C 8A <32 data bytes>" from 32 source bytes into the frame buffer. */
static void build_response(u16 *frame, const u8 *data32)
{
u8 b[36]; int i;
b[0] = 0x00; b[1] = 0x4C; b[2] = 0x8A; /* my fixed reply header */
for (i = 0; i < 32; i++) b[3 + i] = data32[i];
for (i = 0; i < 62; i++) frame[i] = 0;
/* pack byte pairs little-end-first into each MB halfword (verified on the bench) */
for (i = 0; i < 18; i++) frame[i] = (u16)((b[2*i + 1] << 8) | b[2*i]);
}
/* ...and at each call site, right before tx_send: */
frame[18] = (u16)(addr & 0xFFFFu); /* echo the requested address */
frame[19] = REPLY_MAGIC; /* tag it as a fresh data reply */
Con l’eco in posizione, le letture complete da 16 KB tornano intere ogni volta, invece di troncarsi a metà. Se hai mai combattuto con gli slot statici del FlexRay, sai il tipo di bug capriccioso che questo elimina.

lettura. Una lettura completa di flash block0 in MS561: 16 KB indietro, hex a schermo e la console che chiude con flash block0 read OK (16384 bytes) e Flash integrity OK. L’agent è attivo (Agent connected) e sull’unità non c’è JTAG.
Lettura della EEPROM — riportare in vita i pin SPI
La M95640 pende da DSPI_B. L’insidia: il firmware la legge una volta al boot e poi demultiplexa i pad, così quando l’agent gira quei pin non sono più SPI. Il primo passo è rimetterli a posto — multiplexare CS/SCK/SOUT come uscite e SIN come ingresso tramite i registri di controllo pad del SIUL, poi far salire DSPI_B come master a 8 bit lento e sicuro. (I numeri dei pad e il CTAR vengono dritti dalla routine EEPROM di boot della cremagliera stessa.)
Una classica lettura SPI-EEPROM è l’opcode 0x03, l’indirizzo a 16 bit, poi byte dummy clockati per leggere indietro i dati. L’unica sottigliezza su questo DSPI: il chip-select deve restare asserito per tutta la transazione, quindi spingi i frame comando/indirizzo/dummy uno di seguito all’altro con il bit di continuazione impostato, abbassando CS solo sull’ultimo. Un’attesa per ogni byte svuota la FIFO e abbassa CS a metà trasferimento. Perciò ogni byte di dati è un suo ordinato burst di 4 frame.
spi_ee_read — lettura a burst della M95640 su DSPI_B
#define DSPI_B 0xFFF94000u
#define DSPI_MCR (*(volatile u32 *)(DSPI_B + 0x00u))
#define DSPI_CTAR0 (*(volatile u32 *)(DSPI_B + 0x0Cu))
#define DSPI_SR (*(volatile u32 *)(DSPI_B + 0x2Cu))
#define DSPI_PUSHR (*(volatile u32 *)(DSPI_B + 0x34u))
#define DSPI_POPR (*(volatile u32 *)(DSPI_B + 0x38u))
static void spi_ee_init(void)
{
*(volatile u16 *)0xC3F9004Au = 0x0600u; /* PCR5 CS0 out */
*(volatile u16 *)0xC3F9004Cu = 0x0600u; /* PCR6 SCK out */
*(volatile u16 *)0xC3F9004Eu = 0x0600u; /* PCR7 SOUT out */
*(volatile u16 *)0xC3F90050u = 0x0100u; /* PCR8 SIN in */
DSPI_MCR = 0x80010C00u; /* master, PCS0 idle-high, flush FIFOs, running */
DSPI_CTAR0 = 0x38004448u; /* 8-bit frame, mode0, slow baud (safe) */
}
/* READ (0x03): each byte is a 4-frame burst [cmd, addrHi, addrLo(CONT), dummy].
The 4th RX byte is the data; CS stays low for the whole burst. */
static void spi_ee_read(u16 addr, u8 *dst, int len)
{
int i;
spi_ee_init();
for (i = 0; i < len; i++) {
u16 a = (u16)(addr + i);
volatile u32 to = 0;
DSPI_MCR = 0x80010C00u; /* flush FIFOs */
DSPI_SR = 0xFFFF0000u; /* clear status */
DSPI_PUSHR = 0x80010000u | 0x03u; /* READ (CONT) */
DSPI_PUSHR = 0x80010000u | (u32)(a >> 8); /* addr hi(CONT) */
DSPI_PUSHR = 0x80010000u | (u32)(a & 0xFFu); /* addr lo(CONT) */
DSPI_PUSHR = 0x00010000u | 0xFFu; /* dummy, drop CS */
while (((DSPI_SR >> 4) & 0xFu) < 4u) if (++to > 200000u) break;
(void)DSPI_POPR; (void)DSPI_POPR; (void)DSPI_POPR; /* cmd/addr phases */
dst[i] = (u8)(DSPI_POPR & 0xFFu); /* 4th frame = data */
}
}
Scrittura della EEPROM — solo i byte che sono davvero cambiati
Scrivere la M95640 è la danza da manuale: WREN (abilitazione scrittura, 0x06), poi WRITE (0x02) + indirizzo + dati, quindi interrogare il bit WIP del registro di stato finché il ciclo di scrittura da ~5 ms non termina. Di nuovo, l’intero cmd+addr+data viaggia in un unico burst con CS basso.
spi_ee_write_byte — WREN / WRITE / polling WIP
static void spi_ee_write_byte(u16 addr, u8 val)
{
volatile u32 to = 0;
spi_ee_init();
/* WREN */
DSPI_SR = 0xFFFF0000u;
DSPI_PUSHR = 0x00010000u | 0x06u;
to = 0; while (((DSPI_SR >> 4) & 0xFu) < 1u) if (++to > 200000u) break;
(void)DSPI_POPR;
/* WRITE 0x02 + addrHi + addrLo + data (CS held, drop after data) */
DSPI_MCR = 0x80010C00u; DSPI_SR = 0xFFFF0000u;
DSPI_PUSHR = 0x80010000u | 0x02u;
DSPI_PUSHR = 0x80010000u | (u32)(addr >> 8);
DSPI_PUSHR = 0x80010000u | (u32)(addr & 0xFFu);
DSPI_PUSHR = 0x00010000u | (u32)val;
to = 0; while (((DSPI_SR >> 4) & 0xFu) < 4u) if (++to > 200000u) break;
(void)DSPI_POPR; (void)DSPI_POPR; (void)DSPI_POPR; (void)DSPI_POPR;
/* poll WIP until the write cycle completes (~5 ms) */
to = 0; while ((spi_ee_rdsr() & 0x01u) && (++to < 100000u)) { }
}
Due scelte di sicurezza deliberate in come questo viene pilotato:
- Il comando di scrittura porta un byte di guardia. Una scrittura è onorata solo se nella parola di comando è presente un valore di guardia fisso. Un frame spurio o corrotto non può programmare per sbaglio la EEPROM — viene semplicemente scartato.
- L’host scrive una differenza, non un blocco intero. Sul lato MS561 conservo l’ultima lettura completa della EEPROM come snapshot; una scrittura tocca solo i byte che ne differiscono (e mai i campi volatili di runtime), poi rilegge la finestra e verifica che sia andata a buon fine. Se hai mai reso inservibile un modulo riscrivendo un byte che non intendevi toccare, capirai il perché.
In officina questo è di solito il lato dati di una riparazione per salto cinghia. BMW lo registra come DTC 0x482452 — «EPS steering angle sensor: belt jump detected» nel nostro decoder — con 0x4822D9 («…steering angle invalid») come gemello lato hardware, e un contatore di salti cinghia al DID 0xE33C. Nonostante il nome, la cinghia di solito è a posto; semplicemente i dati memorizzati nel modulo non corrispondono più alla cremagliera, e un flash o una codifica non lo cancellano. È riscrivere la EEPROM corretta a rimettere a posto i dati.

scrittura eeprom. Scrittura della EEPROM e rilettura immediata per controllo: EEPROM write verified — 1151 byte(s). Vengono toccati solo i byte cambiati e la rilettura li conferma tutti.
Scrittura flash — calibrazione L/R, con il CRC fatto sul target
Sul 19EE guida a sinistra contro guida a destra non è cosmetica: su una cremagliera a guida a destra il motore di assistenza gira nel verso opposto, quindi il flag deve corrispondere all’auto. Si riduce a due byte di flag in block0, e block0 è protetto da un CRC-32 che il firmware verifica. Cambia i flag senza sistemare il CRC e la centralina rifiuta la calibrazione.
La ricetta l’ho ricavata al banco confrontando un dump LEFT autentico con un dump RIGHT autentico:
block0[0xE9]=0x00per LEFT,0x01per RIGHTblock0[0x4E9]=0xFFper LEFT,0xFEper RIGHT- un CRC-32 zlib/PKZIP standard (polinomio riflesso
0xEDB88320) sublock0[0 .. 0x3E44), memorizzato in big-endian all’indirizzo0x3FCC
Convertire una cremagliera tocca esattamente quei sei byte — nient’altro. E i byte di flag sono due, non uno, perché formano una coppia ridondante: 0x4E9 contiene il complemento a uno (one's-complement) di 0x0E9 (0x00/0xFF, 0x01/0xFE), esattamente 0x400 più avanti, e la parte alta di block0 è specchiata — come NOT bit a bit — allo stesso offset +0x400. È la memorizzazione «valore più inverso» che usano le centraline di sicurezza, e entrambi i byte cadono dentro la regione CRC-32 — quindi una modifica valida significa impostare la coppia in modo coerente e ricalcolare il CRC.
Il CRC corrispondeva esattamente a entrambi i dump di riferimento — ed è così che ho saputo di avere l’intervallo giusto e l’algoritmo giusto. Perciò l’agent porta un suo minuscolo CRC-32 bit-seriale (senza tabella — per tenere l’agent piccolo) e ricalcola il checksum sulla cremagliera dopo aver modificato i flag, così l’immagine programmata è auto-coerente.
crc32_zlib — sul target, senza tabella
/* CRC-32 (zlib/PKZIP: reflected poly 0xEDB88320, init/xorout 0xFFFFFFFF), bit-serial. */
static u32 crc32_zlib(const u8 *p, u32 n)
{
u32 c = 0xFFFFFFFFu, i; int k;
for (i = 0; i < n; i++) {
c ^= p[i];
for (k = 0; k < 8; k++) c = (c & 1u) ? ((c >> 1) ^ 0xEDB88320u) : (c >> 1);
}
return c ^ 0xFFFFFFFFu;
}
La programmazione in sé è il controller C90FL: sbloccare il blocco, cancellarlo, poi riprogrammare doubleword per doubleword, saltando le doubleword vuote (0xFF). Niente di esotico, ma ogni passo è «arma, alta tensione, attendi DONE, controlla PEG (program/erase good)», e un errore qui è una cremagliera morta, quindi conviene essere accorti e ribloccare alla fine.
flash_write_block0 / flash_set_position — cancella, programma, CRC
#define CFLASH_BASE 0xC3F88000u
#define CF_MCR (*(volatile u32 *)(CFLASH_BASE + 0x00u))
#define CF_LML (*(volatile u32 *)(CFLASH_BASE + 0x04u))
#define CF_SLL (*(volatile u32 *)(CFLASH_BASE + 0x0Cu))
#define CF_LMS (*(volatile u32 *)(CFLASH_BASE + 0x10u))
#define MCR_PGM 0x10u
#define MCR_ERS 0x04u
#define MCR_EHV 0x01u
#define MCR_DONE 0x400u
#define MCR_PEG 0x200u
#define LML_PW 0xA1A11111u
#define SLL_PW 0xC3C33333u
static u8 blk[0x4000];
static int flash_write_block0(void)
{
int i; volatile u32 to;
if (!(CF_MCR & MCR_DONE)) return -1;
CF_LML = LML_PW; CF_LML = 0x001303FEu; /* unlock block0 */
CF_SLL = SLL_PW; CF_SLL = 0x001303FEu;
/* erase block0 */
CF_MCR = MCR_ERS;
CF_LMS = 0x00000001u; /* select block0 */
*(volatile u32 *)0x0 = 0xFFFFFFFFu; /* interlock write */
CF_MCR = MCR_ERS | MCR_EHV;
to = 0; while (!(CF_MCR & MCR_DONE)) if (++to > 40000000u) break;
if (!(CF_MCR & MCR_PEG)) { CF_MCR = MCR_ERS; CF_MCR = 0u; CF_LMS = 0u; return -2; }
CF_MCR = MCR_ERS; CF_MCR = 0u; CF_LMS = 0u;
/* reprogram non-blank doublewords from the SRAM snapshot */
for (i = 0; i < 0x4000; i += 8) {
u32 w0 = ((u32)blk[i] << 24) | ((u32)blk[i+1] << 16) | ((u32)blk[i+2] << 8) | blk[i+3];
u32 w1 = ((u32)blk[i+4] << 24) | ((u32)blk[i+5] << 16) | ((u32)blk[i+6] << 8) | blk[i+7];
if (w0 == 0xFFFFFFFFu && w1 == 0xFFFFFFFFu) continue;
CF_MCR = MCR_PGM;
*(volatile u32 *)(u32)i = w0;
*(volatile u32 *)(u32)(i + 4) = w1;
CF_MCR = MCR_PGM | MCR_EHV;
to = 0; while (!(CF_MCR & MCR_DONE)) if (++to > 4000000u) break;
if (!(CF_MCR & MCR_PEG)) { /* re-lock and bail -> restore from backup */ return -3; }
CF_MCR = MCR_PGM; CF_MCR = 0u;
}
CF_LML = LML_PW; CF_LML = 0x001303FFu; /* re-lock */
CF_SLL = SLL_PW; CF_SLL = 0x001303FFu;
return 0;
}
/* snapshot block0, flip L/R flags, recompute CRC, commit */
static int flash_set_position(int right)
{
int i; u32 crc;
if (!(CF_MCR & MCR_DONE)) return -1;
for (i = 0; i < 0x4000; i++) blk[i] = *(const volatile u8 *)(u32)i;
if (right) { blk[0x0E9] = 0x01u; blk[0x4E9] = 0xFEu; }
else { blk[0x0E9] = 0x00u; blk[0x4E9] = 0xFFu; }
crc = crc32_zlib(blk, 0x3E44u);
blk[0x3FCC] = (u8)(crc >> 24); blk[0x3FCD] = (u8)(crc >> 16); /* big-endian */
blk[0x3FCE] = (u8)(crc >> 8); blk[0x3FCF] = (u8)(crc);
return flash_write_block0();
}
Una cancellazione flash è la cosa più pericolosa che l’agent possa fare, perciò il comando che la innesca è dietro una tripla guardia: un opcode dedicato, un byte sentinella e una magic word devono allinearsi tutti nello stesso frame prima che venga chiamata flash_set_position. Un solo bit sbagliato in qualunque punto e la richiesta è ignorata. La risposta porta un sentinella di eco distinto (non un indirizzo) e il codice di ritorno del controller in coda, così l’host capisce che quel frame è la conferma post-scrittura e verifica il risultato per rilettura.
Ho convertito una cremagliera di prova LEFT→RIGHT→LEFT, verificato i dump in ogni verso e l’ho lasciata nella configurazione LEFT originale. ret=0, rilettura corrispondente, reversibile.

scrittura L/R. Il cambio L/R su flash, riletto per conferma: Write verified: steering = RIGHT. Safe to switch off the power. La riga modificata è evidenziata nel dump e il CRC è stato ricalcolato sulla cremagliera.
Il loop dei comandi, tutto insieme
Quattro comandi — lettura flash, lettura EEPROM, scrittura EEPROM, scrittura L/R — ciascuno risposto sullo slot TX con il timbro di eco. L’entry point scrive una firma di vita (00 4C 8A A0 A1 A2 … BF) prima di entrare nel loop, così posso confermare che il mio codice è residente e in esecuzione puramente dal bus, senza alcun JTAG collegato.
agent_main — il dispatcher
void agent_main(void)
{
static u16 frame[64];
static u8 buf[32];
u16 cmd[20]; int n, i, ret; u32 addr;
for (;;) {
n = rx_poll(cmd, 20);
if (n < 3) continue;
if (/* READ flash */ cmd[0] == 0x0017u && (cmd[1] & 0xFF00u) == 0x6300u) {
addr = ((u32)(cmd[1] & 0xFFu) << 16) | cmd[2];
for (i = 0; i < 32; i++) buf[i] = *(const volatile u8 *)(addr + i);
build_response(frame, buf);
frame[18] = (u16)(addr & 0xFFFFu); frame[19] = REPLY_MAGIC;
tx_send(frame, 62);
}
else if (/* READ eeprom */ cmd[0] == 0x0025u && (cmd[1] & 0xFF00u) == 0x6300u) {
addr = ((u32)(cmd[1] & 0xFFu) << 16) | cmd[2];
spi_ee_read((u16)addr, buf, 32);
build_response(frame, buf);
frame[18] = (u16)(addr & 0xFFFFu); frame[19] = REPLY_MAGIC;
tx_send(frame, 62);
}
else if (/* WRITE eeprom (guarded) */ cmd[0] == 0x00B7u /* + guard check */) {
/* ... write the diff bytes, read the window back, reply with read-back ... */
}
else if (/* WRITE L/R (triple-guarded, destructive) */ cmd[0] == 0x00B9u /* + guards */) {
ret = flash_set_position((cmd[1] >> 8) & 0x1);
for (i = 0; i < 30; i++) buf[i] = *(const volatile u8 *)(u32)i;
buf[30] = (u8)(ret & 0xFF); buf[31] = (u8)((ret >> 8) & 0xFF);
build_response(frame, buf);
frame[18] = 0x5A5Au; frame[19] = REPLY_MAGIC;
tx_send(frame, 62);
}
}
}
La «cifratura», in breve — e perché il segreto non mi è mai servito
La memoria non torna in chiaro; il percorso di lettura nel firmware la mette in XOR con un keystream. Spesso viene trattato come un cifrario forte; non lo è. Dopo aver raccolto testo in chiaro noto (regioni cancellate a 0xFF, più la regione di codice quasi identica tra le unità) il keystream risulta una funzione per-indirizzo, lineare su GF(2) — un LFSR/CRC dell’indirizzo, non un vero cifrario a blocchi. C’è anche una spia statistica: il MSB di ogni parola di keystream a 32 bit è sbilanciato, ed è ciò che un generatore lineare da poco lascia trapelare.
Essendo lineare, il keystream è pienamente ricostruibile dal testo in chiaro noto: risolvi un piccolo sistema su un blocco noto, estendi al resto con una parola nota per blocco e puoi decifrare/cifrare qualsiasi unità senza mai estrarre un seed o una chiave segreta. Non c’è quindi alcun segreto da nascondere all’agent — non ne porta. Restituisce i byte grezzi e lascia i conti al lato host. La sequenza di security access l’ho illustrata prima; l’unico pezzo che trattengo è come viene prodotta la chiave, e quello resta nel mio software MS561.
Descriverò la forma della debolezza — un’offuscazione debole va chiamata debole — ma non le costanti per-unità né l’handshake di accesso. Quella parte non è mia da distribuire.
Una nota sull’originalità
Ho sentito dire che i miei strumenti sono «copie 1:1» di quelli di un certo fornitore, quindi una nota al riguardo.
Tutto in questa pagina è uscito dal reverse engineering del firmware in Ghidra: le mappe dei registri, la corsa al lock, il timing SPI, la ricetta del CRC dai miei dump left/right, il sorgente dell’agent qui sopra. Il metodo è qui per intero, sorgente incluso.
Il protocollo in sé è mio: l’eco di risposta 0x4321, l’header di risposta 00 4C 8A, il lock «cicla finché il CC non cede», la cancellazione a tripla guardia. Se spuntano verbatim in un altro binario, trai da solo la conclusione su in che verso sia andata.
Merhaba. Buona lettura. 👋
Risultati
| Operazione | Trasporto | Stato |
|---|---|---|
| Lettura flash (blocchi da 16 KB, immagine completa) | FlexRay, senza JTAG | diff-0 rispetto al riferimento, validata più volte (~27 s / 16 KB) |
| Lettura EEPROM (intero M95640) | FlexRay, senza JTAG | byte per byte esatta, validata (~14 s / 8 KB) |
| Scrittura EEPROM (solo byte cambiati) | FlexRay, senza JTAG | rilettura CORRISPONDE, reversibile |
| Scrittura flash (flag L/R + CRC) | FlexRay, senza JTAG | ret=0, verificata per rilettura, reversibile |
Nessuna sonda JTAG sull’unità, nessun segreto cotto dentro l’agent — solo un piccolo programma nella SRAM della cremagliera che risponde alle richieste via FlexRay, e un banco che ora sa leggere e scrivere una cremagliera 19EE da capo a fondo.
Il resto dell’agent — il driver lato host completo e il set di comandi — resta sul mio banco, ma le parti qui sopra erano quelle difficili.
Riferimenti
- NXP, MPC5643L Microcontroller Reference Manual — Flash Memory Array and Control (C90FL): i registri di lock LML/SLL (offset
0x04/0x0C) e le loro password di modifica del lock,0xA1A11111e0xC3C33333. - Community NXP, programmazione dei registri di lock C90FL su parti MPC5xxx affini: esempio MPC5644A, blocco FLASH MPC5744P.
Ringraziamenti
Un ringraziamento speciale ai nostri colleghi in Brasile e in Messico per il loro aiuto nello sviluppo di questa soluzione. Apprezziamo molto il vostro supporto e la vostra collaborazione!