evocode 0.1.0__py3-none-any.whl

evocode/__init__.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+"""evocode — read, decode, sign and write BMW NBT EVO (QNX) coding over ENET/HSFZ.
+
+Pure Python standard library. Platform scope: NBT EVO / QNX (iDrive ID4/ID5/ID6)
+only — NOT MGU / ID7+ (Linux). See docs/scope.md.
+
+The mechanism is constant across NBT EVO builds; what changes per car is data —
+the BTLD-selected signing key and the per-CAFD bit catalog. Read the SVK first and
+key off the unit's real BTLD + CAFD ids; never assume them.
+"""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

evocode/caf.py

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Decrypt a BMW CAFD ``.caf`` into its plaintext CAFD XML.
+
+A ``.caf`` is an XML wrapper::
+
+    <caf isEncrypted="true" isCompressed="true"><encryptedData>BASE64(CMS)</encryptedData></caf>
+
+The inner CMS is a PKCS#7 EnvelopedData encrypted to the **Codier-Encrypt** certificate, whose RSA
+private key lives (alongside the E-SYS key) in your ``sec_security.lic`` keystore. The decrypted
+payload is **gzip**-compressed CAFD XML. So: recover the Codier-Encrypt key (derived keystore
+password, see :mod:`evocode.psdz`), CMS-decrypt, gunzip.
+
+Needs the ``crypto`` extra and an ``openssl`` binary (OpenSSL 3.x): cryptography exposes only one of
+the keystore's two private keys and has no EnvelopedData-decrypt API, so the second key and the CMS
+decrypt go through ``openssl``. Everything else is pure stdlib.
+"""
+from __future__ import annotations
+
+import base64
+import gzip
+import re
+import shutil
+import subprocess
+import tempfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from . import psdz
+
+
+def _ln(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def cms_from_caf(caf_path) -> bytes:
+    """The DER CMS EnvelopedData from a .caf's <encryptedData> (or the file itself if already CMS)."""
+    data = Path(caf_path).read_bytes()
+    try:
+        root = ET.fromstring(data)
+    except ET.ParseError:
+        return data
+    ed = next((e for e in root.iter() if _ln(e.tag) == "encryptedData"), None)
+    if ed is None:
+        raise ValueError("%s is not an encrypted .caf (no <encryptedData>)" % caf_path)
+    return base64.b64decode("".join((ed.text or "").split()))
+
+
+def decrypt_caf(caf_path, psdzdata, *, resource_jar=None, logo=None, mini=None,
+                recipient="Codier-Encrypt") -> bytes:
+    """Return the plaintext CAFD XML bytes for an encrypted ``.caf``."""
+    from cryptography.hazmat.primitives.serialization import Encoding, load_pem_private_key, pkcs12
+
+    sec = Path(psdzdata) / "security"
+    lic = sec / "sec_security.lic"
+    password = psdz.derive_password(lic, resource_jar=resource_jar, logo=logo, mini=mini)
+    der = psdz.keystore_der(lic)
+    _key, _cert, chain = pkcs12.load_key_and_certificates(der, password)
+    recips = [c for c in (chain or []) if recipient in c.subject.rfc4514_string()]
+    if not recips:
+        raise KeyError("recipient cert %r not found in sec_security.lic" % recipient)
+    n = recips[0].public_key().public_numbers().n
+
+    tmp = tempfile.mkdtemp(prefix="evocode-caf-")
+    try:
+        p12 = Path(tmp, "ks.p12"); p12.write_bytes(der)
+        cms = Path(tmp, "cms.der"); cms.write_bytes(cms_from_caf(caf_path))
+        rcert = Path(tmp, "recip.pem"); rcert.write_bytes(recips[0].public_bytes(Encoding.PEM))
+        dump = subprocess.run(["openssl", "pkcs12", "-legacy", "-in", str(p12),
+                               "-passin", "pass:" + password.decode(), "-nodes"],
+                              capture_output=True, text=True).stdout
+        rkey = None
+        for block in re.findall(r"-----BEGIN PRIVATE KEY-----.*?-----END PRIVATE KEY-----", dump, re.S):
+            if load_pem_private_key(block.encode(), password=None).public_key().public_numbers().n == n:
+                rkey = Path(tmp, "recip_key.pem"); rkey.write_text(block)
+                break
+        if rkey is None:
+            raise KeyError("recipient private key (%s) not found in keystore" % recipient)
+        out = subprocess.run(["openssl", "cms", "-decrypt", "-inform", "DER", "-in", str(cms),
+                              "-inkey", str(rkey), "-recip", str(rcert)], capture_output=True)
+        if out.returncode != 0:
+            raise RuntimeError("openssl cms decrypt failed: %s" % out.stderr.decode()[:200])
+        payload = out.stdout
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    return gzip.decompress(payload) if payload[:2] == b"\x1f\x8b" else payload

evocode/catalog.py

@@ -0,0 +1,127 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Per-CAFD bit catalogs: load one and decode a read NCD against it.
+
+A catalog is one JSON file per CAFD (see catalogs/README.md): a list of parameters, each addressing
+a coding bitfield by (datagroup, byte, mask, shift) with optional value labels. Decoding is purely
+mechanical — the catalog is the data. The names/labels in a catalog are reconstructed descriptions
+(firmware-traced or token-derived), authored and grown by the community, not shipped BMW data.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from . import srec
+
+
+@dataclass
+class Param:
+    name: str
+    dg: int
+    byte: int
+    mask: int
+    shift: int
+    values: Dict[int, str] = field(default_factory=dict)
+    default: Optional[int] = None
+    token: Optional[str] = None
+
+
+def _int(x) -> int:
+    if isinstance(x, int):
+        return x
+    s = str(x).strip()
+    if s.endswith("b"):                 # binary mask like "10000000b"
+        return int(s[:-1], 2)
+    return int(s, 0)                     # "0x80", "128", "0b1000"
+
+
+def _shift_of(mask: int) -> int:
+    return (mask & -mask).bit_length() - 1 if mask else 0
+
+
+def load(path: str) -> List[Param]:
+    doc = json.loads(open(path, encoding="utf-8").read())
+    records = doc["parameters"] if isinstance(doc, dict) else doc
+    out: List[Param] = []
+    for r in records:
+        mask = _int(r.get("mask", 0xFF))
+        shift = int(r["shift"]) if "shift" in r else _shift_of(mask)
+        dg = _int(r["datagroup"] if "datagroup" in r else r["dg"])
+        default = r.get("default")
+        out.append(Param(
+            name=r.get("name") or r.get("token") or r.get("coord") or "?",
+            dg=dg, byte=int(r["byte"]), mask=mask, shift=shift,
+            values={_int(k): v for k, v in (r.get("values") or {}).items()},
+            default=_int(default) if default not in (None, "") else None,
+            token=r.get("token"),
+        ))
+    return out
+
+
+def decode(mem: srec.Mem, params: List[Param]):
+    """Yield (param, raw_value, label_or_None) for each parameter whose byte is present in mem."""
+    for p in params:
+        addr = (p.dg << 8) + p.byte
+        if addr not in mem:
+            continue
+        raw = (mem[addr] & p.mask) >> p.shift
+        yield p, raw, p.values.get(raw)
+
+
+# ---- building a catalog skeleton from a decrypted CAFD XML ----
+
+def _mask_int(s: str) -> int:
+    s = (s or "").strip()
+    return int(s[:-1], 2) if s.endswith("b") else int(s, 0)
+
+
+def build_skeleton(cafd_xml: bytes) -> dict:
+    """Turn a decrypted CAFD XML (see evocode.caf) into a catalog skeleton: every coding coordinate
+    with its datagroup, byte, mask, shift and factory default. Parameter NAMES and value labels are
+    left blank — BMW ships the CAFD with those stripped; they are a firmware-token / community overlay.
+    """
+    import xml.etree.ElementTree as ET
+
+    def ln(t):
+        return t.rsplit("}", 1)[-1]
+
+    root = ET.fromstring(cafd_xml)
+    data = next(e for e in root.iter() if ln(e.tag) == "data")
+    params = []
+    for dg in data:
+        if ln(dg.tag) != "datagroup":
+            continue
+        addr = dg.attrib.get("address", "")
+        for f in dg:
+            if ln(f.tag) != "function":
+                continue
+            si = next((c for c in f if ln(c.tag) == "storageInfo"), None)
+            if si is None:
+                continue
+            get = lambda nm: next((c.text for c in si if ln(c.tag) == nm), None)  # noqa: E731
+            start, mask = get("start"), get("mask")
+            if start is None or mask is None:
+                continue
+            m = _mask_int(mask)
+            rec = {
+                "name": "" if f.attrib.get("name", ".") in (".", "") else f.attrib["name"],
+                "datagroup": "0x%s" % addr.upper(),
+                "byte": int(start),
+                "mask": "0x%02X" % m,
+                "shift": (m & -m).bit_length() - 1 if m else 0,
+            }
+            dv = next((c for c in f if ln(c.tag) == "defVal"), None)
+            if dv is not None:
+                uv = next((c for c in dv if ln(c.tag) == "unitVal"), None)
+                if uv is not None and (uv.text or "").strip():
+                    try:
+                        rec["default"] = int(uv.text.strip(), 16)
+                    except ValueError:
+                        pass
+            params.append(rec)
+    return {"cafd": "", "version": "",
+            "note": "Skeleton from `evocode build-catalog`: coordinates/masks/defaults are factual, "
+                    "from your CAFD. Parameter names/value-labels are blank — add them from the "
+                    "firmware-token layer (community overlay); see catalogs/README.md.",
+            "parameters": params}