evocode 0.1.0__py3-none-any.whl

evocode/coding.py

@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: Apache-2.0
+"""The NBT EVO coding signature (BMWSigVerify) — the maths the head unit runs at every boot.
+
+A signature covers the content datagroups, is computed with the key the bootloader (BTLD) selects,
+and lives in its own datagroup. Edit any coding byte without recomputing it and the change reverts
+on the next boot. Verifying needs only the public modulus; producing a signature needs the private
+exponent (recover it from your own PSdZData — never shipped here).
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from . import srec
+
+
+@dataclass(frozen=True)
+class Scheme:
+    """Which datagroups are signed, with which digest, and where the signature is stored."""
+    name: str
+    content_dgs: Tuple[int, ...]
+    sig_dg: int
+    digest: str                       # "md5" or "sha256"
+
+    @property
+    def digest_len(self) -> int:
+        return hashlib.new(self.digest).digest_size
+
+
+# NBT EVO (QNX): datagroups 0x3000..0x300F signed with MD5, signature in 0x3010.
+NBTEVO = Scheme("nbtevo", tuple(range(0x3000, 0x3010)), 0x3010, "md5")
+SCHEMES = {NBTEVO.name: NBTEVO}
+DEFAULT_SCHEME = NBTEVO.name
+
+
+@dataclass
+class Key:
+    modulus: int
+    public_exponent: int = 3
+    private_exponent: Optional[int] = None
+    btld: Optional[str] = None
+
+    @property
+    def size(self) -> int:
+        return (self.modulus.bit_length() + 7) // 8
+
+
+def load_key(path: str) -> Key:
+    d = json.loads(open(path, encoding="utf-8").read())
+    priv = d.get("private_exponent_hex")
+    return Key(
+        modulus=int(d["modulus_hex"], 16),
+        public_exponent=int(d.get("public_exponent", 3)),
+        private_exponent=int(priv, 16) if priv else None,
+        btld=d.get("btld"),
+    )
+
+
+def _wordswap(b: bytes) -> bytes:
+    """Reverse the bytes within each 32-bit word — BMW's big-number storage order."""
+    if len(b) % 4:
+        raise ValueError("length must be a multiple of 4")
+    return b"".join(b[i:i + 4][::-1] for i in range(0, len(b), 4))
+
+
+def content_digest(mem: srec.Mem, scheme: Scheme = NBTEVO) -> bytes:
+    pages = srec.pages(mem, scheme.content_dgs)
+    content = b"".join(pages[dg] for dg in scheme.content_dgs if dg in pages)
+    return hashlib.new(scheme.digest, content).digest()
+
+
+def sign(mem: srec.Mem, key: Key, scheme: Scheme = NBTEVO) -> bytes:
+    """The raw signature bytes over the current content (does not modify ``mem``)."""
+    if key.private_exponent is None:
+        raise ValueError("key has no private exponent; recover it from your own PSdZData")
+    m = int.from_bytes(content_digest(mem, scheme), "little")
+    s = pow(m, key.private_exponent, key.modulus)
+    return _wordswap(s.to_bytes(key.size, "little"))
+
+
+def signature_page(sig: bytes, key: Key) -> bytes:
+    """Signature datagroup payload: big-endian 32-bit word count, then the signature."""
+    return (key.size // 4).to_bytes(4, "big") + sig
+
+
+def resign(mem: srec.Mem, key: Key, scheme: Scheme = NBTEVO) -> bytes:
+    """Recompute the signature and write it into the signature datagroup, in place."""
+    sig = sign(mem, key, scheme)
+    base = scheme.sig_dg << 8
+    for i, b in enumerate(signature_page(sig, key)):
+        mem[base + i] = b
+    return sig
+
+
+def verify(mem: srec.Mem, key: Key, scheme: Scheme = NBTEVO) -> bool:
+    """Reproduce the ECU's check: raise the stored signature to ``e``, compare to the content digest."""
+    digest = content_digest(mem, scheme)
+    page = srec.pages(mem, [scheme.sig_dg]).get(scheme.sig_dg, b"")
+    if len(page) < 4 + key.size:
+        return False
+    sig = page[4:4 + key.size]
+    recovered = pow(int.from_bytes(_wordswap(sig), "little"), key.public_exponent, key.modulus)
+    return (recovered.to_bytes(scheme.digest_len, "little") == digest
+            and recovered.bit_length() <= 8 * scheme.digest_len)

evocode/consent.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Owner-consent gate for anything that writes to a vehicle.
+
+A deliberate speed bump: a write refuses unless you have set ``NBTEVO_OWN_VIN`` to the VIN of the
+car you own, and that VIN matches the one the tool reads back from the connected car. This is not
+DRM — it is a guard against writing to the wrong vehicle. Do not route around it.
+"""
+from __future__ import annotations
+
+import os
+
+ENV_VIN = "NBTEVO_OWN_VIN"
+
+
+class ConsentError(RuntimeError):
+    pass
+
+
+def owned_vin() -> str:
+    vin = os.environ.get(ENV_VIN, "").strip()
+    if not vin:
+        raise ConsentError("set %s to the VIN of the car you own before any write." % ENV_VIN)
+    return vin
+
+
+def assert_owned(connected_vin: str) -> None:
+    want = owned_vin()
+    if connected_vin.strip() != want:
+        raise ConsentError(
+            "connected VIN %r != %s (%r) — refusing to write to a car you have not confirmed you own."
+            % (connected_vin, ENV_VIN, want)
+        )

evocode/fsc.py

@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: Apache-2.0
+"""FSC activations — the owner-CA path: your own e=3 trust anchor, and FSCs you mint under it.
+
+The NBT EVO verifies every "long" FSC against ONE RSA modulus — **blobB** — compiled into NBTCarHU
+(``e=3``, PKCS#1 v1.5 / MD5). There is no per-feature key and no certificate lookup: an FSC is
+accepted iff its signature verifies under whatever modulus is installed as blobB. This is a separate
+mechanism from coding (which verifies against BMW's fixed Codier-Sign key you can only *recover*).
+
+The owner path, on a car you own: generate your **own** e=3 key, install its modulus as blobB (a
+length-preserving firmware patch — see ``find_blobb``/``patch_blobb``), and mint FSCs with your
+private key. No BMW key is forged; you move the unit's trust to a key you hold.
+
+``keygen``/``mint``/``verify``/``parse``/``recover_modulus`` are pure stdlib. ``recover_modulus``
+(the e=3 GCD attack) identifies the anchor already on a used unit from the FSCs you read off it.
+"""
+from __future__ import annotations
+
+import hashlib
+import math
+import secrets
+import struct
+from collections import Counter
+from math import gcd
+from typing import List, Tuple
+
+MD5_DIGESTINFO = bytes.fromhex("3020300c06082a864886f70d020505000410")
+BODY_LEN = 60
+SIG_LEN = 128
+
+# the application numbers this tooling was built around
+APPNOS = {0x0143: "CarPlay", 0x00A0: "Navi Pro ECE", 0x0120: "Map Europe", 0x009C: "A4A / BMW Apps"}
+
+
+# ---- the 60-byte signed body (byte-exact to the EVO FSC layout) ----
+
+def build_body(appno: int, upgrade_idx: int = 1, supplier_id: bytes = b"       1",
+               requester_type: bytes = b"       1", counter: int = 0x0001,
+               fscs_id: bytes = b"C329361", vin=None, date: bytes = b"201608242124") -> bytes:
+    b = bytearray(b"\x01\x01")
+    b += struct.pack(">H", appno)
+    b += struct.pack(">H", upgrade_idx)
+    assert len(supplier_id) == 8
+    b += supplier_id + b"\x01"
+    assert len(requester_type) == 8
+    b += requester_type
+    b += struct.pack(">H", counter) + b"\x01"
+    assert len(fscs_id) == 7
+    b += fscs_id + b"\x01"                               # VIN-type 1 => a 9-byte VIN follows
+    b += (b"\x00" * 9) if vin is None else (vin if isinstance(vin, bytes) else vin.encode())
+    b += b"\x04\x02"                                     # date tag/len
+    assert len(date) == 12
+    b += date + b"Z\x00\x00"
+    assert len(b) == BODY_LEN, "body len %d" % len(b)
+    return bytes(b)
+
+
+def _emsa(digest: bytes, modlen: int = SIG_LEN) -> bytes:
+    """PKCS#1 v1.5 envelope over an MD5 digest, zero-slack (what the device expects)."""
+    t = MD5_DIGESTINFO + digest
+    return b"\x00\x01" + b"\xff" * (modlen - 3 - len(t)) + b"\x00" + t
+
+
+def _emsa_int(body: bytes) -> int:
+    return int.from_bytes(_emsa(hashlib.md5(body).digest()), "big")
+
+
+# ---- mint / resign / verify / parse ----
+
+def mint(n: int, d: int, appno: int, **body_kw) -> bytes:
+    """A 188-byte FSC (60-byte body + 128-byte signature) signed by private (n, d), e=3."""
+    body = build_body(appno, **body_kw)
+    return body + pow(_emsa_int(body), d, n).to_bytes(SIG_LEN, "big")
+
+
+def resign_body(body: bytes, n: int, d: int) -> bytes:
+    """Re-sign an existing 60-byte body under (n, d) — reuse a real FSC's fields exactly."""
+    return bytes(body[:BODY_LEN]) + pow(_emsa_int(body[:BODY_LEN]), d, n).to_bytes(SIG_LEN, "big")
+
+
+def verify(fsc: bytes, n: int, e: int = 3):
+    """Reproduce the on-device check: m = sig^e mod N, strip PKCS#1, compare MD5(body)."""
+    body, sigb = fsc[:-SIG_LEN], fsc[-SIG_LEN:]
+    sig = int.from_bytes(sigb, "big")
+    if sig >= n:
+        return False, "sig>=N"
+    m = pow(sig, e, n).to_bytes(SIG_LEN, "big")
+    if m[:2] != b"\x00\x01":
+        return False, "bad 00 01"
+    i = 2
+    while i < SIG_LEN and m[i] == 0xFF:
+        i += 1
+    if m[i] != 0x00:
+        return False, "FF run not 00-terminated"
+    i += 1
+    if m[i:i + 18] != MD5_DIGESTINFO:
+        return False, "bad DigestInfo"
+    if i + 34 != SIG_LEN:
+        return False, "envelope not exactly 128 bytes"
+    if m[i + 18:i + 34] != hashlib.md5(body).digest():
+        return False, "hash mismatch"
+    return True, "OK"
+
+
+def parse(fsc: bytes) -> dict:
+    b = fsc[:-SIG_LEN]
+    vin = b[34:43]
+    return {
+        "version": b[0:2].hex(),
+        "appno": "0x%04X" % struct.unpack(">H", b[2:4])[0],
+        "upgrade_index": struct.unpack(">H", b[4:6])[0],
+        "fscs_id": b[26:33].decode("latin1"),
+        "vin": "(VIN-generic)" if vin == b"\x00" * 9 else vin.decode("latin1"),
+        "creation_date": b[45:57].decode("latin1"),
+    }
+
+
+# ---- whose anchor signed these? (e=3 modulus recovery) ----
+
+def recover_modulus(fscs: List[bytes]) -> int:
+    """Recover the signing modulus from >=2 FSCs signed by the SAME anchor (e=3 GCD attack)."""
+    if len(fscs) < 2:
+        raise ValueError("need >=2 FSCs signed by the same anchor to recover a modulus")
+    g = 0
+    for f in fscs:
+        body, sigb = f[:-SIG_LEN], f[-SIG_LEN:]
+        g = gcd(g, abs(int.from_bytes(sigb, "big") ** 3 - _emsa_int(body)))
+    p = 2
+    while p < 100000:                                    # strip tiny cofactors, keep the ~1024-bit N
+        while g % p == 0 and (g // p).bit_length() >= 1000:
+            g //= p
+        p += 1
+    return g
+
+
+def blobB_le(n: int) -> bytes:
+    """The 128-byte blobB form of a modulus: little-endian (as it sits in NBTCarHU)."""
+    return n.to_bytes(SIG_LEN, "little")
+
+
+def fingerprint(n: int) -> str:
+    return hashlib.sha256(blobB_le(n)).hexdigest()[:16]
+
+
+# ---- generate your own e=3 anchor ----
+
+def _probable_prime(num: int, rounds: int = 24) -> bool:
+    for sp in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37):
+        if num % sp == 0:
+            return num == sp
+    if num < 2:
+        return False
+    d, r = num - 1, 0
+    while d % 2 == 0:
+        d //= 2
+        r += 1
+    for _ in range(rounds):
+        a = 2 + secrets.randbelow(num - 3)
+        x = pow(a, d, num)
+        if x in (1, num - 1):
+            continue
+        for _ in range(r - 1):
+            x = pow(x, 2, num)
+            if x == num - 1:
+                break
+        else:
+            return False
+    return True
+
+
+def _prime_e3(bits: int) -> int:
+    """A prime p with (p-1) coprime to 3, so e=3 is invertible."""
+    while True:
+        cand = secrets.randbits(bits) | (1 << (bits - 1)) | 1
+        while not _probable_prime(cand):
+            cand += 2
+        if (cand - 1) % 3 != 0:
+            return cand
+
+
+def keygen(bits: int = 1024) -> dict:
+    """Your owner trust anchor: RSA with e=3 (what the FSC verifier uses)."""
+    p = _prime_e3(bits // 2)
+    q = _prime_e3(bits // 2)
+    while q == p:
+        q = _prime_e3(bits // 2)
+    n = p * q
+    phi = (p - 1) * (q - 1)
+    return {"n_hex": "%x" % n, "e": 3, "d_hex": "%x" % pow(3, -1, phi), "bits": n.bit_length()}
+
+
+# ---- locating / swapping blobB in a NBTCarHU firmware dump ----
+
+def _entropy(b: bytes) -> float:
+    c = Counter(b)
+    n = len(b)
+    return -sum((v / n) * math.log2(v / n) for v in c.values())
+
+
+def _small_primes(limit: int = 50000) -> List[int]:
+    s = bytearray([1]) * limit
+    s[0] = s[1] = 0
+    for i in range(2, int(limit ** 0.5) + 1):
+        if s[i]:
+            s[i * i::i] = bytearray(len(s[i * i::i]))
+    return [i for i in range(limit) if s[i]]
+
+
+def find_blobb(nbtcarhu: bytes, bits: int = 1024) -> Tuple[int, int]:
+    """Locate the installed FSC anchor in a NBTCarHU ELF dump → (file_offset, modulus).
+
+    The verifier loads blobB's address from a PC-relative literal pool, so the real modulus's
+    virtual address appears verbatim as a 4-byte little-endian pointer in the code. Among the
+    high-entropy ~1024-bit candidates in the binary, exactly the installed one is code-referenced —
+    which pins it with no stock image or disassembler.
+    """
+    d = nbtcarhu
+    if d[:4] != b"\x7fELF" or d[4] != 1:
+        raise ValueError("not an ELF32 image (expected a NBTCarHU dump)")
+    phoff = struct.unpack("<I", d[28:32])[0]
+    phentsize = struct.unpack("<H", d[42:44])[0]
+    phnum = struct.unpack("<H", d[44:46])[0]
+    segs = []
+    for i in range(phnum):
+        o = phoff + i * phentsize
+        ptype, poff, pvaddr, _ppaddr, pfilesz = struct.unpack("<5I", d[o:o + 20])
+        if ptype == 1:                                  # PT_LOAD
+            segs.append((poff, pvaddr, pfilesz))
+
+    def off2va(o):
+        for poff, pvaddr, pfilesz in segs:
+            if poff <= o < poff + pfilesz:
+                return pvaddr + (o - poff)
+        return None
+
+    L = len(d)
+    nbytes = bits // 8
+
+    # This build wraps the anchor in a little key struct { ver(u32)=1, e(u32)=3, len_words(u32),
+    # modulus }, and the code references the STRUCT address — so find a code-referenced struct of the
+    # wanted width and take the modulus at +12.
+    want_words = bits // 32
+    o = 0
+    while o + 12 + nbytes <= L:
+        ver, e3, lw = struct.unpack("<3I", d[o:o + 12])
+        if ver == 1 and e3 == 3 and lw == want_words:
+            va = off2va(o)
+            if va is not None and d.find(struct.pack("<I", va)) >= 0:
+                moff = o + 12
+                n = int.from_bytes(d[moff:moff + nbytes], "little")
+                if (n & 1) and n.bit_length() >= bits - 8:
+                    return moff, n
+        o += 4
+
+    # Fallback: a build that stores the modulus unwrapped — find the single code-referenced candidate.
+    primes = _small_primes()
+    o = 0
+    while o + nbytes <= L:
+        if (d[o] & 1) and (d[o + nbytes - 1] & 0x80):
+            w = d[o:o + nbytes]
+            if _entropy(w) > 6.4:
+                n = int.from_bytes(w, "little")
+                if n.bit_length() >= bits - 7 and all(n % p for p in primes):
+                    va = off2va(o)
+                    if va is not None and d.find(struct.pack("<I", va)) >= 0:
+                        return o, n
+        o += 4
+    raise LookupError("blobB not located by code reference (PIC/GOT? pass an explicit offset)")
+
+
+def patch_blobb(nbtcarhu: bytes, offset: int, modulus: int) -> bytes:
+    """A copy of the dump with the 128 bytes at ``offset`` replaced by ``modulus`` (length-preserving)."""
+    d = bytearray(nbtcarhu)
+    d[offset:offset + SIG_LEN] = blobB_le(modulus)
+    return bytes(d)

evocode/hsfz.py

@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: Apache-2.0
+"""HSFZ transport for BMW F/early-G ENET diagnostics (the NBT EVO host).
+
+These cars speak **HSFZ**, not DoIP, over TCP 6801. A frame is::
+
+    u32 payload_len | u16 control | u8 source | u8 target | UDS bytes...
+
+where ``payload_len`` counts the bytes after the control word (so ``2 + len(UDS)`` for a data
+frame). control 0x0001 = data, 0x0002 = ack. Discovery is a UDP broadcast of control 0x0011 to
+port 6811; each gateway answers, and the reply's source IP is the endpoint. Routing is the target
+byte alone — connect once and set ``target`` per ECU; the gateway forwards it.
+
+Addresses: tester source 0xF4, FEM gateway 0x10, NBT EVO head unit 0x63.
+"""
+from __future__ import annotations
+
+import socket
+import struct
+import threading
+import time
+from dataclasses import dataclass
+from typing import Callable, List, Optional
+
+IDENT_PORT = 6811
+DIAG_PORT = 6801
+
+CTRL_DATA = 0x0001
+CTRL_ACK = 0x0002
+CTRL_IDENT = 0x0011
+
+SRC_TESTER = 0xF4
+TGT_GATEWAY = 0x10
+TGT_HU = 0x63
+
+
+class HsfzError(Exception):
+    pass
+
+
+@dataclass
+class Endpoint:
+    ip: str
+    diag_addr: Optional[int]
+    vin: Optional[str]
+    raw_ident: str
+
+
+def _parse_ident(payload: bytes, ip: str) -> Endpoint:
+    text = payload.decode("latin1", "replace")
+
+    def field(tag: str, n: int) -> Optional[str]:
+        i = text.find(tag)
+        return text[i + len(tag): i + len(tag) + n] if i >= 0 else None
+
+    da = field("DIAGADR", 2)
+    vin = field("BMWVIN", 17)
+    return Endpoint(ip, int(da, 16) if da else None, vin.strip("\x00 ") if vin else None, text)
+
+
+def discover(bind_ip: str, broadcast: str = "169.254.255.255", timeout: float = 3.0) -> List[Endpoint]:
+    """Broadcast the HSFZ ident request on the ENET segment and collect endpoint replies.
+
+    ``bind_ip`` is your host's address on that segment (e.g. a 169.254.x.x link-local), so the probe
+    leaves the right interface.
+    """
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    sock.bind((bind_ip, 0))
+    sock.settimeout(timeout)
+    sock.sendto(struct.pack(">IH", 0, CTRL_IDENT), (broadcast, IDENT_PORT))
+    found: dict[str, Endpoint] = {}
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            data, (ip, _) = sock.recvfrom(4096)
+        except socket.timeout:
+            break
+        if len(data) >= 6 and ip not in found:
+            found[ip] = _parse_ident(data[6:], ip)
+    sock.close()
+    return list(found.values())
+
+
+class Hsfz:
+    """One TCP/6801 HSFZ session. Set the target per request; the gateway routes by it."""
+
+    def __init__(self, ip: str, source: int = SRC_TESTER, timeout: float = 5.0):
+        self.ip = ip
+        self.source = source
+        self._timeout = timeout
+        self.sock = socket.create_connection((ip, DIAG_PORT), timeout=timeout)
+        self.sock.settimeout(timeout)
+        self._tp_stop: Optional[threading.Event] = None
+        self._tp_thread: Optional[threading.Thread] = None
+
+    def close(self) -> None:
+        self.stop_tester_present()
+        try:
+            self.sock.close()
+        except OSError:
+            pass
+
+    def reconnect(self, timeout: Optional[float] = None) -> "Hsfz":
+        try:
+            self.sock.close()
+        except OSError:
+            pass
+        t = timeout or self._timeout
+        self.sock = socket.create_connection((self.ip, DIAG_PORT), timeout=t)
+        self.sock.settimeout(t)
+        return self
+
+    def __enter__(self) -> "Hsfz":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def send_only(self, target: int, uds: bytes) -> None:
+        self._send(target, uds)
+
+    def recv_frame(self, timeout: Optional[float] = None) -> tuple[int, bytes]:
+        if timeout is not None:
+            self.sock.settimeout(timeout)
+        return self._recv_frame()
+
+    def start_tester_present(self, target: int = 0xDF, period: float = 1.0,
+                             log: Optional[Callable] = None) -> None:
+        if self._tp_thread is not None:
+            return
+        self._tp_stop = threading.Event()
+        tp = bytes([0x3E, 0x80])
+
+        def _loop() -> None:
+            assert self._tp_stop is not None
+            while not self._tp_stop.wait(period):
+                try:
+                    self._send(target, tp)
+                except Exception:
+                    break
+
+        self._tp_thread = threading.Thread(target=_loop, name="HSFZ-TP", daemon=True)
+        self._tp_thread.start()
+        if log:
+            log("  [tp] TesterPresent 3E 80 -> 0x%02X every %.1fs" % (target, period))
+
+    def stop_tester_present(self) -> None:
+        if self._tp_stop is not None:
+            self._tp_stop.set()
+        if self._tp_thread is not None:
+            self._tp_thread.join(timeout=1.0)
+            self._tp_thread = None
+        self._tp_stop = None
+
+    def _send(self, target: int, uds: bytes) -> None:
+        frame = struct.pack(">IH", 2 + len(uds), CTRL_DATA) + bytes([self.source, target]) + uds
+        self.sock.sendall(frame)
+
+    def _recv_exact(self, n: int) -> bytes:
+        buf = b""
+        while len(buf) < n:
+            chunk = self.sock.recv(n - len(buf))
+            if not chunk:
+                raise HsfzError("HSFZ peer closed the connection")
+            buf += chunk
+        return buf
+
+    def _recv_frame(self) -> tuple[int, bytes]:
+        length, ctrl = struct.unpack(">IH", self._recv_exact(6))
+        body = self._recv_exact(length) if length else b""
+        return ctrl, body
+
+    def request(self, target: int, uds: bytes, p2_star: float = 6.0) -> bytes:
+        """Send a UDS request and return the raw UDS response, skipping acks/echoes and riding the
+        extended P2* timer across ``7F xx 78`` responsePending frames."""
+        self._send(target, uds)
+        deadline = time.time() + p2_star
+        while time.time() < deadline:
+            try:
+                ctrl, body = self._recv_frame()
+            except socket.timeout:
+                break
+            if ctrl != CTRL_DATA or len(body) < 2:
+                continue                                   # ack / status frame
+            resp = body[2:]                                # strip source, target
+            if not resp or resp == uds:
+                continue                                   # some gateways echo the request
+            if len(resp) >= 3 and resp[0] == 0x7F and resp[2] == 0x78:
+                deadline = time.time() + p2_star           # responsePending: keep waiting
+                continue
+            return resp
+        raise HsfzError("no UDS response from 0x%02X for %s" % (target, uds.hex()))