From cfd6cd4e71893e6d382756bdd2b583cb8009cda6 Mon Sep 17 00:00:00 2001 From: fenleon Date: Thu, 8 Oct 2026 19:35:39 +0200 Subject: [PATCH] NAC sign ported to Kotlin (NacSign): full mint in-repo; spec rev 31; NacMint facade MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The verified pure-python sign model (sig_hand/sig_init/sig_tail) is now transcribed to Kotlin: NacSignTablesData.kt carries 102 tables as generated base64 source (ClearAdiTablesData precedent, provenance header), NacSign.kt runs the pipeline (u32tab → scatter → perms → keygen → phases B–E → rounds → genBufs → threshold-cipher tail), and NacValidation.mint computes sig16 internally — the full 517-B stamp from Kotlin inputs. Pinned by 5 synthetic LCG vectors against the python model (208 tests, 0 failed; table images re-decoded and compared table-by-table, 32/32). Spec rev 31; README status updated. NacMint: minimal public facade for consumers (the imessage tool wires ClearAnisetteProvider + the mint behind its AnisetteSource/ ValidationDataSource seams). --- README.md | 2 +- docs/imessage-protocol-spec.md | 5 +- .../dev/fenn/imessage/registration/NacMint.kt | 28 + .../dev/fenn/imessage/registration/NacSign.kt | 797 ++++++++++++++++++ .../imessage/registration/NacSignTables.kt | 108 +++ .../registration/NacSignTablesData.kt | 167 ++++ .../imessage/registration/NacValidation.kt | 24 +- .../fenn/imessage/registration/NacSignTest.kt | 70 ++ .../registration/NacValidationTest.kt | 20 +- 9 files changed, 1213 insertions(+), 8 deletions(-) create mode 100644 registration/src/main/kotlin/dev/fenn/imessage/registration/NacMint.kt create mode 100644 registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt create mode 100644 registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt create mode 100644 registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt create mode 100644 registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt diff --git a/README.md b/README.md index 285b4bb..1b36c69 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ Validated: - The registration chain ran live against Apple (2026-10-02→04, spec rev 26): Albert activation, the packed APNs courier, the full GSA sign-in (SRP, trusted-device 2FA, PET delivery, postdata), then IDS authenticate and register — both green, `mailto:` handle active. The earlier 409 refusals turned out to be Apple's validation-stamp replay guard (one mint = one device record), documented in the spec. - Two live unauthenticated probes against Apple succeeded: both bag endpoints return plists this stack parses, and certificate pinning validates Apple's real TLS chains. A drift check ships with the repo (`:engine:runProbe`). - The courier's auth model is settled: the packed path needs no client certificate; the legacy path answers the handshake with a TLS 1.3 post-handshake `certificate_required` alert. -- The ADI anisette chain is reimplemented natively, no emulation or helper binary: the white-box OTP ciphers, the GSA provisioning exchange, the full spim/cpim/ptm wire framing, and the validation-stamp ("NAC") mint — pear white-box cipher, blob assembly, and the 16-byte OTS signature — are transcribed clean-room from analysis of a compiled ADI implementation, verified byte-exact against oracle vectors and live captures (three genuine provisioning runs plus a validation-stamp capture under an instrumented debugger). Every byte group of the exchange and of the 517-byte stamp is identified and reproduced; the full stamp computes byte-exact from its inputs (python reference model — the Kotlin signature port is the next step; 206 tests green, spec rev 30). No anisette server, no Unicorn, no Mac relay. +- The ADI anisette chain is reimplemented natively, no emulation or helper binary: the white-box OTP ciphers, the GSA provisioning exchange, the full spim/cpim/ptm wire framing, and the validation-stamp ("NAC") mint — pear white-box cipher, blob assembly, and the 16-byte OTS signature (`NacSign`) — are transcribed clean-room from analysis of a compiled ADI implementation, verified byte-exact against oracle vectors and live captures (three genuine provisioning runs plus a validation-stamp capture under an instrumented debugger). Every byte group of the exchange and of the 517-byte stamp is identified and reproduced; the full stamp computes byte-exact in Kotlin from its inputs (the earlier python reference model is retired to dev capture notes; the Kotlin port is pinned by synthetic-vector tests against it). 208 tests green, spec rev 31. A minimal public facade (`NacMint`) exposes the mint for consumers; the remaining gap to a live stamp is five wire-input mappings from the validation exchange, each named in the spec (§1.1 C56). No anisette server, no Unicorn, no Mac relay. Not validated yet: diff --git a/docs/imessage-protocol-spec.md b/docs/imessage-protocol-spec.md index e22b95f..c7329af 100644 --- a/docs/imessage-protocol-spec.md +++ b/docs/imessage-protocol-spec.md @@ -1,6 +1,6 @@ # iMessage protocol spec (clean-room) -**Status:** draft — revision 30. The full revision history is at the bottom ([Revision history](#revision-history)); the sections below state the facts as of rev 30. +**Status:** draft — revision 31. The full revision history is at the bottom ([Revision history](#revision-history)); the sections below state the facts as of rev 31. **Firewall rule:** this document contains facts only — no code, no function/type names, no copied expression from any reference implementation. Wire-format field names are quoted as on-the-wire protocol data (observable in captures, capture-arbitrated), never as source expression. Facts derived from SSPL/AGPL sources are used facts-only; nothing from them is reproduced. Where the source-derived fact sets agree, the fact is stated once with both citations; where they disagree, the disagreement is stated and tagged `TODO(capture):` — running mitmproxy captures arbitrate. All `TODO(capture)` items are collected in §7. @@ -21,7 +21,7 @@ - Current shipped flow (OpenBubbles, 2026): the Mac-side helper (`Mac-Hardware-Info` 1.2.0, notarized) only *reads* the machine identifiers — serial, board ID, model, etc. — via public IORegistry/sysctl APIs (docs: "High Sierra and above", no upper macOS version bound) and exports them as a shareable code (≤ 20 users per code, optional one-time-use/48-hour mode); it never invokes an Apple private framework [OB-MHI], [OB-FAQ]. The client then performs the three-step exchange above itself, in software, keyed with those identifiers and paired with an Apple-Account login — the [JJ] emulation path with an official identifier-export helper in front of it. `TODO(capture):` **C56** — the client-side generation procedure behind the three-step exchange: what the client computes with the `id-initialize-validation` session info (the key-establishment math and blob assembly), how it interacts with the Apple-Account/GSA login and the anisette header set (C6) at activation time, and which pieces are fixed protocol constants vs per-account/per-session state. — 2026-09-10: steps 1–2 of C56 are recorded (bullet above); step 3 — key establishment + signing — is closed source: the public OpenAbsinthe-Stub repo is an official mock whose methods are stubs (its README states the real repository is closed source), so the spec records only the API contract: context creation consumes the certificate chain + hardware configuration and outputs the session-info-request blob; key establishment consumes the server response; signing produces the final blob with no further inputs (all state retained in the context) [RP:macos.rs], [RP:activation.rs], [RP:auth.rs], [OA]. Remaining: wire-verification of the blob against one live activation; the enc-variant derivation rides C57. — 2026-09-11 (rev 14 extraction): the five obfuscation labels are now MAPPED to their fields (previously only listed together): serial → `Gq3489ugfi`, platform UUID → `Fyp98tpgj`, root-disk UUID → `kbjfrfpoJU`, ROM → `oycqAZloTNDm`, MLB → `abKPld1EcMni` [OA:nac.rs]; the derivation producing each `_enc` byte variant is still closed source. The hardware-configuration field set is recorded in full: product name (Apple product-type form, e.g. `Macmini9,1`), MAC address (exactly 6 raw bytes), platform serial, platform UUID, root-disk UUID, board ID, OS build number, ROM (raw bytes), MLB, plus the five `_enc` raw-byte variants [OA:nac.rs]. Step 3's closure is confirmed at the source level: the crate holding the key-establishment math ships as a closed-source stub whose mock methods panic; only the API contract is observable [OA:README.md], [OA:nac.rs]. - The helper's export-code format (2026-09-11, rev 15 — **C58 closed** by facts-only extraction from the helper's public upstream repo, which is unlicensed — facts only): the payload is a 4-byte ASCII magic `OABS`, a one-byte flag (1 = "prevent sharing" mode, 0 otherwise), then a raw protobuf message (no length prefix; protobuf starts at offset 5). Protobuf field map: outer — 1 nested identifier message, 2 macOS product version (sysctl `kern.osproductversion`), 3 protocol version (hardcoded `1640`), 4 device id (the IOPlatformUUID again), 5 a hardcoded iCloudHelper user-agent string, 6 a hardcoded AOSKit version string; nested identifier message — 1 product name (e.g. `MacBookPro18,3`), 2 MAC address (6 raw bytes), 3 platform serial, 4 platform UUID, 5 root-disk UUID, 6 board ID (Apple Silicon: literal prefix `Mac-` + lowercase hex of the device-tree board-id bytes), 7 OS build number (sysctl `kern.osversion`), 8/9/10/12/14 the five `_enc` obfuscated blobs read from the `IOPower:/` registry under Apple's key names (`Gq3489ugfi` serial, `Fyp98tpgj` platform UUID, `kbjfrfpoJU` root-disk UUID, `oycqAZloTNDm` ROM, `abKPld1EcMni` MLB — matching §1.1's label mapping), 11 ROM (Intel: the device-tree options ROM value; Apple Silicon: last 6 bytes of SHA-256 of `/chosen` `unique-chip-id`), 13 MLB string. Two delivery modes: plain = standard base64 of the payload (clipboard text, or the raw payload bytes as a QR code at medium error correction); restricted = AES-256-CBC/PKCS7 over the payload, ciphertext prefixed with ASCII `Salted__` + 8-byte random salt (legacy OpenSSL `enc` container), key/IV derived by the legacy EVP_BytesToKey KDF (repeated MD5 of previous-hash ‖ password ‖ salt to 48 bytes: first 32 = key, next 16 = IV) keyed by a human activation code (`MB` + 4×4 chars from the alphabet `ABCDEFGHJKLMNPQRSTUVWXYZ123456789`), then base64. The restricted mode additionally uploads the blob (JSON `data` + `id` = lowercase hex SHA-256 of the activation code) to the vendor's server (`hw.openbubbles.app/code`) — the ≤20-user/one-time/48-hour mechanics live SERVER-side; nothing is embedded in the payload (no checksum, signature, compression, or expiry). No public parser exists (the client apps are closed-source); the construction above is the parse specification [MHG:ViewController.swift], [MHG:HwIdentifiers.swift], [MHG:mac_hw_info.pb.swift]. - The validation blob is submitted as the `validation-data` field of the IDS register body and, base64, in the `X-Mme-Nas-Qualify` header of the iCloud account login [RP:ids/user.rs], [RP:auth.rs]. `TODO(capture):` C5 — exact byte shape of the blob a genuine Mac produces, and the current exchange over the two validation bag URLs. — 2026-10-04 (rev 26, live): **REPLAY GUARD — one mint = one device record.** Apple keys a validation blob's consumption server-side: re-submitting an already-consumed blob at the sign-in/register pair answers HTTP 409, which is a REPLAY refusal, NOT a blob rejection — a fresh blob under the same device identity succeeds where the reused one failed, and a captured blob of external provenance succeeds outright (session 17: a captured stamp replaced the local mint and the 409 vanished). Client consequences: mint or fetch a fresh blob per registration attempt (the 15-minute validity above makes stale reuse doubly fatal), and mint the sign-in's blob AT SIGN-IN TIME — never a login-start blob carried across the 2FA wait. A caller-injected blob from any source (local mint, relay Mac, staged capture) is a legitimate stamp; the injection points are the register body's `validation-data` and the sign-in's `X-Mme-Nas-Qualify` header. -- Hardware-related anisette headers seen in activation flows: `X-Apple-I-SRL-NO` (serial), `X-Apple-I-MLB` (logic-board serial), `X-Apple-I-ROM` (hex ROM, lowercase) [RP:relay.rs], [APA:anisette]. `TODO(capture):` C6 — the full anisette header set a current client actually sends, including which optional hardware headers appear. — 2026-09-10: the header-set half of C6 is closed by facts-only extraction: per-request anisette headers `X-Apple-I-Client-Time`, `X-Apple-I-TimeZone`, `X-Apple-Locale`, `X-Apple-I-MD-RINFO`, `X-Mme-Device-Id`, `X-Apple-I-MD` (base64 OTP), `X-Apple-I-MD-M` (base64 machine ID), plus per-platform hardware headers — macOS: `X-Apple-I-MLB`, `X-Apple-I-ROM` (lowercase hex), `X-Apple-I-SRL-NO` [APA:omnisette], [APA:icloud-auth], [RP:relay.rs]. They are produced by an ADI provisioning exchange with gsa.apple.com (start/finish provisioning returning machine tokens), then a local OTP [APA:omnisette]. GSA context (cross-referenced with C6): the Albert activation itself needs NO Apple-Account login — only the FairPlay-signed activation-info plist (§1.2); the GSA login (full Apple-ID password, SRP over gsa.apple.com/grandslam/GsService2, s2k/s2k_fo PBKDF2, 2FA-capable) feeds the delegate logins that yield the IDS `auth-token`/`profile-id` and the PET token [RP:auth.rs], [APA:icloud-auth]. The extraction confirms the validation blob rides base64 in the `X-Mme-Nas-Qualify` header of the iCloud sign-in POST (recorded above) [RP:auth.rs]. — 2026-09-11 (rev 14 extraction round over the anisette crates): the value-format and provisioning halves of C6 are closed. Per-request value forms: `X-Apple-I-Client-Time` = UTC now truncated to whole seconds, RFC 3339/ISO-8601 with the offset suffix replaced by `Z` (provisioning requests send the raw offset form without the Z — a recorded inconsistency between code paths); `X-Apple-I-TimeZone` = literal `UTC` (not the device zone); `X-Apple-Locale` = `en_US` hardcoded (a companion `X-Apple-I-Locale: en_US` variant exists on the browser-style header set); `X-Apple-I-MD-RINFO` = verbatim passthrough of the string returned in the finish-provisioning response; `X-Mme-Device-Id` = lowercase hyphenated UUID string of 16 locally random bytes (`keychain_identifier`); `X-Apple-I-MD-M` = base64 (standard, padded) of the 60-byte `mid`; `X-Apple-I-MD-LU` = lowercase hex (no dashes) SHA-256 over the same 16 bytes (real macOS instead uses AuthKit's local-user UUID) — present in some header sets, omitted in others (disagreement — C57). Header sets are cached 60 s; a fresh OTP is generated per cache miss. The ADI provisioning flow: `GET https://gsa.apple.com/grandslam/GsService2/lookup` → XML plist whose `urls` keys `midStartProvisioning`/`midFinishProvisioning` give the endpoint URLs (never hardcoded); POST to the start URL with an XML plist body of two empty top-level dicts `Header` and `Request` → response `Response` → `spim` (base64); a local session is built from `spim` (+ empty hostuuid, DSID `-2`, flavor `Mac`=1 / `IOS`=3, flavor chosen by whether the client-info string contains `iPhone OS`) yielding `cpim` (base64); POST to the finish URL with `Request` = {`cpim`} → response `Response` → `ptm`, `tk` (both base64) and `X-Apple-I-MD-RINFO`; finishing the session with the decoded `tk`/`ptm` yields the machine state: `client_secret` (32 bytes), `mid` (60 bytes, Apple-issued at provisioning — reused for every OTP until re-provisioning, which happens only on a not-provisioned failure, e.g. ADI error -45061), `metadata` (variable blob). Provisioning HTTP specifics: `Content-Type: application/x-www-form-urlencoded` despite the XML-plist body (intentional), title-cased header names forced, HTTP/1.1, Apple root CA pinned (embedded DER), and a fixed companion header set on all three requests: akd `User-Agent`, `X-Apple-Baa-E: -10000`, `X-Apple-Baa-Avail: 2`, `X-Apple-Baa-UE: AKAuthenticationError:-7066|com.apple.devicecheck.error.baa:-10000`, `X-Apple-Host-Baa-E: -7066`, `X-Apple-Client-App-Name: akd`, `Accept: */*`, `Accept-Language: en-US,en;q=0.9`, plus `X-Apple-I-MD-LU`, `X-Mme-Device-Id`, `X-Mme-Client-Info`, `X-Apple-I-Client-Time` and any caller-supplied hardware headers. State persists as an XML plist with `keychain_identifier` (data) + the provisioned fields (`client_secret`, `mid`, `metadata`, `rinfo`, `flavor`) [APA:omnisette]. CLOSED-SOURCE RESIDUE: the OTP (`X-Apple-I-MD`) and trusted-device 2FA-code derivations live inside a closed-source crate — its public repo is a stub with `todo!()` methods; recorded is only the call contract: inputs (32-byte `client_secret`, 60-byte `mid`, `metadata`, flavor) → raw OTP bytes (base64 into the header) / 32-bit 2FA code [OA-stub], [APA:omnisette]. — rides C57/C56 residue; the seam stays injectable in the code. — 2026-10-07 (rev 27, clean-room RE of the OpenBubbles ADI library — unstripped Linux `.so`, oracle-verified; the derivation is no longer closed residue): the OTP is fully local and pure. `gen = unix_seconds / 30`; dispatch by OTP flavor byte: 1 (IOS) → `gen_otp` (0x17fba60), 0 (Mac) → `gen_otp_ios` (0x1801d90) — the binary's naming is inverted relative to the flavor (a distinct numbering from the §1.1 session flavor `Mac`=1/`IOS`=3). Cipher inputs: `one` = the machine's `client_info` (required ≥ 0x190 B IOS / ≥ 0xd0 B Mac, length-checked) and `two` = the 32-byte `mid`; output 16 bytes. The wire `X-Apple-I-MD` frame is 28 B: `u32be(5)` ‖ `u32be(16)` ‖ sig16 ‖ `u32be(flavor)`. The 2FA code is `SHA-1(sig16 ‖ secret60) mod 1_000_000` over the machine's full 60-byte secret slice (`machine[0x38..0x74]`; two standard SHA-1 blocks — an earlier report's "48-byte" reading is wrong, 0x18013a2/0x18013bb/0x18013ef). Provisioning framing, asm-pinned: `spim` = `field1` u32 BE @0 ‖ payload-length u32 BE @4 ‖ payload @8 (payload must exceed 59 B, 0x17efb33; more than 23 trailing bytes rejected with error 0x41); `cpim` = 9 fields (u32be(32) ‖ `encsec(rng2)` 32 B ‖ u32be(32) ‖ rng1 32 B ‖ 60 B blob = caller-extra ‖ rng3 pad ‖ u64 BE of arg9 = −2 ‖ u32 BE of the byte-swapped LE dword at rng3[8..12] ‖ two 256-bit tail fields fed by `encrypt(session, rng16, data)` + `spim_map_signature` — the tail's exact wire assembly is `TODO(capture)`); `ptm` is lenient (u32 BE then the whole tail — every candidate shape accepted, error 0); finish requires `tk` exactly 16 B (error 0x8, 0x17f1f11), key16 = `encrypt(session, NULL iv, tk)` (0x17f1eac), decrypt block count = payload.size/16 (0x17f2548), yielding the 0x78-byte provisioned struct (+0x00 16 B, +0x10 u64, +0x18 u64, +0x20 16 B, +0x30..0x70 64 B metadata, +0x70 u32, +0x74 u8 flavor — which bytes are `client_secret` vs `mid` vs `metadata` is `TODO(capture)`). Kotlin: `registration` module `ClearAdiOtp`/`ClearAdiProvision`/`ClearAdiFraming`/`ClearAnisetteProvider`, 192 tests green incl. byte-exact oracle vectors. — 2026-10-07 (rev 28, live capture: one real OpenBubbles provisioning run under gdb, `registration/dev/clearadi/captures/WIRE-NOTES.md`; the framer is corrected): `spim` trailing is NOT capped at 23 B — the live spim carries 99 trailing bytes and parses fine (the earlier 0x41 pin was a probe-harness artifact); the trailing is server material the client relays. `cpim` = an OUTER 276-B message `[u32be(5)][iv 16][u32be(160)][encout 160][X 32][u32be(52)][u32be(4)][Y 52]` whose 160-B encrypt plaintext = `u32be(32) ‖ encsec(rng2) ‖ u32be(32) ‖ rng1 ‖ 60 B blob (caller-extra ‖ rng3 pad) ‖ u64 BE arg9 = −2 (live-confirmed) ‖ u32 BE unix-seconds ‖ u32be(1) ‖ 12 B (source TODO)`; the iv is 16 plain RNG bytes — the earlier 'IV assembled from the Spim's trailing fields' reading was actually the thread-RNG pool (words at r14+0x10, cursor at r14+0x110). `spim_map_signature` (0x17fe2a0) args are (rdi = in, rsi = out): the live call signs a constant 16-B block `e955a4f0…` → `f877c30e…`, and NEITHER that signature nor the SHA-256(encout) digest appears anywhere in the captured wire — the §6 'two 256-bit tail fields' reading is falsified. The `[u32be(52)][u32be(4)][Y 52]` group is the spim's trailing[16:76] relayed verbatim; X (32 B) = `TODO(capture)`. `ptm` = `[u32 BE 4][seed 16][u32 BE payloadLen][payload][tail]` (live 503 B: seed = ptm[4:20] feeds decryptPTM as its chain seed via rcx; block count = payloadLen/16 = 28); key16 = `encrypt(session, NULL iv, tk)` confirmed byte-exact against the live call. ProvisionedData = the 0x78-B Rust struct `{metadata: Vec (400 B live = decrypt out[4:404], length u32 BE at out[0]), client_secret = rng2 (32 B), mid = rng3 (60 B), flavor u8 (0x01 on a live Mac run — distinct from the OTP flavor numbering)}`; the finish gate is the decrypt output's **out[408:440] == rng1 echo** (NOT out[0:32]); the OTP-path report's ProvisionedMachine note (mid[32]@+0x18, secret[60]@+0x38) had the two swapped. Kotlin `ClearAdiFraming`/`ClearAnisetteProvider` restructured to the live shapes; 194 tests green. Remaining `TODO(capture)`: the X32 source, the 12-B plaintext tail, trailing[0:16]'s role. — 2026-10-07 (rev 29, continuation capture — two further live provisioning runs, `gdb_prov8/9.gdb`, byte-exact on both): the three remaining cpim TODOs are CLOSED. X = SHA-256(encout ‖ spim_map_signature(trailing[0:16]) ‖ a fixed 24-byte filler constant `3795020c05f77009cbfeaa78a5bcb3175bad60b9deaaaa8d` (.so .rodata) — the digest is written to the wire byte-exact as the `[X 32]` group, so the rev-28 "sig16 and the digest appear nowhere on the wire" note resolves: both are on the wire transitively (sig16 as the hash input, the digest as X). The signature's INPUT is NOT a constant block — the "constant e955a4f0…" seen in the morning runs was that session's trailing[0:16]; the trailing head is server material that differs between provisioning sessions, and the signature model still reproduces the live output exactly. The 12-B plaintext tail = 12 fresh RNG bytes (low bytes of 12 thread-RNG pool words drawn immediately before the IV's 16 — the same construction as the IV, so the framer draws 12). Kotlin: the pinned production seal (`CpimShaTailSeal` — SHA-256 via the platform, sig via the ported `spimMapSignature`) is the provider default; 195 tests green. — 2026-10-08 (rev 30, clean-room RE of the NAC mint — the validation blob "C5" — over the same unstripped Linux `.so`; gdb oracle quadruples first, then python model, then Kotlin; method + findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the mint is local and pure, and every byte of the 517-B validation stamp is now derived EXCEPT one residue (below). The stamp = `0x02 ‖ rand16 (RNG) ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`; blob480 = `tag 0x05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79`, where cert79 is the first 79 B of the ctx cert chain and session250 the 250-B session slice — E2E the full stamp computes byte-exact from (cert79, session250, rng_pad130, body576, rand16). The crypto layers, all byte-exact vs three independent live runs: **pear_aes** — a white-box AES variant (`create_rounds` = AES-128-style expansion with pluggable sbox/rcon; `init_key` = S1-scramble → schedule; `establish_key` = schedule + T-transform of blocks 1–9 only, blocks 0/10 raw; `encrypt_cbc` = whitening + **9 rounds** + final `SE[st9[p]]^rk11` with p=[12,10,4,3,15,5,2,8,14,1,9,7,0,13,11,6]; `decrypt_cbc` = backward rounds with the key xor fused into the table index, final `perm(SDI[st9^rk1])^chain^rk0`); **domergestep2** — the white-box core of `scramble_body` (KP key schedule over 80 B, 4 blocks of the `0x51·m` constant with state[0] xored on EVERY block, final `TC[x]+k`, out = state ⊕ in1; 21/21 live captures); **key_establishment** — the EstablishKeyResponse wire is `tag ‖ key16@0x01 ‖ u32be bodyLen@0x11 ‖ body@0x15 (0x250) ‖ trailing (85 B, unused by the crypto)`. **SignState::sign** (the 16-B OTS signature over the blob): structure fully decoded — scatter → polynomial chain → flag table → u32 permutations → divisor table → key map → keygen → matrix/phases B–F → 16 position rounds → tail (fold chains + threshold cipher + staging + final formula); stages 1–9 are hand-transcribed and byte-exact vs ground truth, the tail's threshold cipher (AES-like, 9 rounds × 30 generator runs) is structurally decoded with 270 checkpointed rounds, and the signature the model produces is byte-exact vs the live stamp. CLOSED (same day, follow-up): the capture-free pure-code transcription of the tail cipher and the pre-init region — the full 517-B stamp now computes byte-exact from (cert79, session250, rng_pad130, body576, rand16) in a pure-Python model (no emulator, no captures; `sig_hand.py verify` 20/20) with the complete constant inventory recorded for the Kotlin port (see WORKLOG session 20). Kotlin: `registration` `PearTablesData`/`PearTables` (generated base64 table image, ClearAdiTablesData pattern), `PearAes`, `NacMerge`, `NacValidation` (`mint` + `keyEstablishment`; sig16 a parameter — no placeholder signature), 206 tests green (synthetic vectors, no Apple bytes). +- Hardware-related anisette headers seen in activation flows: `X-Apple-I-SRL-NO` (serial), `X-Apple-I-MLB` (logic-board serial), `X-Apple-I-ROM` (hex ROM, lowercase) [RP:relay.rs], [APA:anisette]. `TODO(capture):` C6 — the full anisette header set a current client actually sends, including which optional hardware headers appear. — 2026-09-10: the header-set half of C6 is closed by facts-only extraction: per-request anisette headers `X-Apple-I-Client-Time`, `X-Apple-I-TimeZone`, `X-Apple-Locale`, `X-Apple-I-MD-RINFO`, `X-Mme-Device-Id`, `X-Apple-I-MD` (base64 OTP), `X-Apple-I-MD-M` (base64 machine ID), plus per-platform hardware headers — macOS: `X-Apple-I-MLB`, `X-Apple-I-ROM` (lowercase hex), `X-Apple-I-SRL-NO` [APA:omnisette], [APA:icloud-auth], [RP:relay.rs]. They are produced by an ADI provisioning exchange with gsa.apple.com (start/finish provisioning returning machine tokens), then a local OTP [APA:omnisette]. GSA context (cross-referenced with C6): the Albert activation itself needs NO Apple-Account login — only the FairPlay-signed activation-info plist (§1.2); the GSA login (full Apple-ID password, SRP over gsa.apple.com/grandslam/GsService2, s2k/s2k_fo PBKDF2, 2FA-capable) feeds the delegate logins that yield the IDS `auth-token`/`profile-id` and the PET token [RP:auth.rs], [APA:icloud-auth]. The extraction confirms the validation blob rides base64 in the `X-Mme-Nas-Qualify` header of the iCloud sign-in POST (recorded above) [RP:auth.rs]. — 2026-09-11 (rev 14 extraction round over the anisette crates): the value-format and provisioning halves of C6 are closed. Per-request value forms: `X-Apple-I-Client-Time` = UTC now truncated to whole seconds, RFC 3339/ISO-8601 with the offset suffix replaced by `Z` (provisioning requests send the raw offset form without the Z — a recorded inconsistency between code paths); `X-Apple-I-TimeZone` = literal `UTC` (not the device zone); `X-Apple-Locale` = `en_US` hardcoded (a companion `X-Apple-I-Locale: en_US` variant exists on the browser-style header set); `X-Apple-I-MD-RINFO` = verbatim passthrough of the string returned in the finish-provisioning response; `X-Mme-Device-Id` = lowercase hyphenated UUID string of 16 locally random bytes (`keychain_identifier`); `X-Apple-I-MD-M` = base64 (standard, padded) of the 60-byte `mid`; `X-Apple-I-MD-LU` = lowercase hex (no dashes) SHA-256 over the same 16 bytes (real macOS instead uses AuthKit's local-user UUID) — present in some header sets, omitted in others (disagreement — C57). Header sets are cached 60 s; a fresh OTP is generated per cache miss. The ADI provisioning flow: `GET https://gsa.apple.com/grandslam/GsService2/lookup` → XML plist whose `urls` keys `midStartProvisioning`/`midFinishProvisioning` give the endpoint URLs (never hardcoded); POST to the start URL with an XML plist body of two empty top-level dicts `Header` and `Request` → response `Response` → `spim` (base64); a local session is built from `spim` (+ empty hostuuid, DSID `-2`, flavor `Mac`=1 / `IOS`=3, flavor chosen by whether the client-info string contains `iPhone OS`) yielding `cpim` (base64); POST to the finish URL with `Request` = {`cpim`} → response `Response` → `ptm`, `tk` (both base64) and `X-Apple-I-MD-RINFO`; finishing the session with the decoded `tk`/`ptm` yields the machine state: `client_secret` (32 bytes), `mid` (60 bytes, Apple-issued at provisioning — reused for every OTP until re-provisioning, which happens only on a not-provisioned failure, e.g. ADI error -45061), `metadata` (variable blob). Provisioning HTTP specifics: `Content-Type: application/x-www-form-urlencoded` despite the XML-plist body (intentional), title-cased header names forced, HTTP/1.1, Apple root CA pinned (embedded DER), and a fixed companion header set on all three requests: akd `User-Agent`, `X-Apple-Baa-E: -10000`, `X-Apple-Baa-Avail: 2`, `X-Apple-Baa-UE: AKAuthenticationError:-7066|com.apple.devicecheck.error.baa:-10000`, `X-Apple-Host-Baa-E: -7066`, `X-Apple-Client-App-Name: akd`, `Accept: */*`, `Accept-Language: en-US,en;q=0.9`, plus `X-Apple-I-MD-LU`, `X-Mme-Device-Id`, `X-Mme-Client-Info`, `X-Apple-I-Client-Time` and any caller-supplied hardware headers. State persists as an XML plist with `keychain_identifier` (data) + the provisioned fields (`client_secret`, `mid`, `metadata`, `rinfo`, `flavor`) [APA:omnisette]. CLOSED-SOURCE RESIDUE: the OTP (`X-Apple-I-MD`) and trusted-device 2FA-code derivations live inside a closed-source crate — its public repo is a stub with `todo!()` methods; recorded is only the call contract: inputs (32-byte `client_secret`, 60-byte `mid`, `metadata`, flavor) → raw OTP bytes (base64 into the header) / 32-bit 2FA code [OA-stub], [APA:omnisette]. — rides C57/C56 residue; the seam stays injectable in the code. — 2026-10-07 (rev 27, clean-room RE of the OpenBubbles ADI library — unstripped Linux `.so`, oracle-verified; the derivation is no longer closed residue): the OTP is fully local and pure. `gen = unix_seconds / 30`; dispatch by OTP flavor byte: 1 (IOS) → `gen_otp` (0x17fba60), 0 (Mac) → `gen_otp_ios` (0x1801d90) — the binary's naming is inverted relative to the flavor (a distinct numbering from the §1.1 session flavor `Mac`=1/`IOS`=3). Cipher inputs: `one` = the machine's `client_info` (required ≥ 0x190 B IOS / ≥ 0xd0 B Mac, length-checked) and `two` = the 32-byte `mid`; output 16 bytes. The wire `X-Apple-I-MD` frame is 28 B: `u32be(5)` ‖ `u32be(16)` ‖ sig16 ‖ `u32be(flavor)`. The 2FA code is `SHA-1(sig16 ‖ secret60) mod 1_000_000` over the machine's full 60-byte secret slice (`machine[0x38..0x74]`; two standard SHA-1 blocks — an earlier report's "48-byte" reading is wrong, 0x18013a2/0x18013bb/0x18013ef). Provisioning framing, asm-pinned: `spim` = `field1` u32 BE @0 ‖ payload-length u32 BE @4 ‖ payload @8 (payload must exceed 59 B, 0x17efb33; more than 23 trailing bytes rejected with error 0x41); `cpim` = 9 fields (u32be(32) ‖ `encsec(rng2)` 32 B ‖ u32be(32) ‖ rng1 32 B ‖ 60 B blob = caller-extra ‖ rng3 pad ‖ u64 BE of arg9 = −2 ‖ u32 BE of the byte-swapped LE dword at rng3[8..12] ‖ two 256-bit tail fields fed by `encrypt(session, rng16, data)` + `spim_map_signature` — the tail's exact wire assembly is `TODO(capture)`); `ptm` is lenient (u32 BE then the whole tail — every candidate shape accepted, error 0); finish requires `tk` exactly 16 B (error 0x8, 0x17f1f11), key16 = `encrypt(session, NULL iv, tk)` (0x17f1eac), decrypt block count = payload.size/16 (0x17f2548), yielding the 0x78-byte provisioned struct (+0x00 16 B, +0x10 u64, +0x18 u64, +0x20 16 B, +0x30..0x70 64 B metadata, +0x70 u32, +0x74 u8 flavor — which bytes are `client_secret` vs `mid` vs `metadata` is `TODO(capture)`). Kotlin: `registration` module `ClearAdiOtp`/`ClearAdiProvision`/`ClearAdiFraming`/`ClearAnisetteProvider`, 192 tests green incl. byte-exact oracle vectors. — 2026-10-07 (rev 28, live capture: one real OpenBubbles provisioning run under gdb, `registration/dev/clearadi/captures/WIRE-NOTES.md`; the framer is corrected): `spim` trailing is NOT capped at 23 B — the live spim carries 99 trailing bytes and parses fine (the earlier 0x41 pin was a probe-harness artifact); the trailing is server material the client relays. `cpim` = an OUTER 276-B message `[u32be(5)][iv 16][u32be(160)][encout 160][X 32][u32be(52)][u32be(4)][Y 52]` whose 160-B encrypt plaintext = `u32be(32) ‖ encsec(rng2) ‖ u32be(32) ‖ rng1 ‖ 60 B blob (caller-extra ‖ rng3 pad) ‖ u64 BE arg9 = −2 (live-confirmed) ‖ u32 BE unix-seconds ‖ u32be(1) ‖ 12 B (source TODO)`; the iv is 16 plain RNG bytes — the earlier 'IV assembled from the Spim's trailing fields' reading was actually the thread-RNG pool (words at r14+0x10, cursor at r14+0x110). `spim_map_signature` (0x17fe2a0) args are (rdi = in, rsi = out): the live call signs a constant 16-B block `e955a4f0…` → `f877c30e…`, and NEITHER that signature nor the SHA-256(encout) digest appears anywhere in the captured wire — the §6 'two 256-bit tail fields' reading is falsified. The `[u32be(52)][u32be(4)][Y 52]` group is the spim's trailing[16:76] relayed verbatim; X (32 B) = `TODO(capture)`. `ptm` = `[u32 BE 4][seed 16][u32 BE payloadLen][payload][tail]` (live 503 B: seed = ptm[4:20] feeds decryptPTM as its chain seed via rcx; block count = payloadLen/16 = 28); key16 = `encrypt(session, NULL iv, tk)` confirmed byte-exact against the live call. ProvisionedData = the 0x78-B Rust struct `{metadata: Vec (400 B live = decrypt out[4:404], length u32 BE at out[0]), client_secret = rng2 (32 B), mid = rng3 (60 B), flavor u8 (0x01 on a live Mac run — distinct from the OTP flavor numbering)}`; the finish gate is the decrypt output's **out[408:440] == rng1 echo** (NOT out[0:32]); the OTP-path report's ProvisionedMachine note (mid[32]@+0x18, secret[60]@+0x38) had the two swapped. Kotlin `ClearAdiFraming`/`ClearAnisetteProvider` restructured to the live shapes; 194 tests green. Remaining `TODO(capture)`: the X32 source, the 12-B plaintext tail, trailing[0:16]'s role. — 2026-10-07 (rev 29, continuation capture — two further live provisioning runs, `gdb_prov8/9.gdb`, byte-exact on both): the three remaining cpim TODOs are CLOSED. X = SHA-256(encout ‖ spim_map_signature(trailing[0:16]) ‖ a fixed 24-byte filler constant `3795020c05f77009cbfeaa78a5bcb3175bad60b9deaaaa8d` (.so .rodata) — the digest is written to the wire byte-exact as the `[X 32]` group, so the rev-28 "sig16 and the digest appear nowhere on the wire" note resolves: both are on the wire transitively (sig16 as the hash input, the digest as X). The signature's INPUT is NOT a constant block — the "constant e955a4f0…" seen in the morning runs was that session's trailing[0:16]; the trailing head is server material that differs between provisioning sessions, and the signature model still reproduces the live output exactly. The 12-B plaintext tail = 12 fresh RNG bytes (low bytes of 12 thread-RNG pool words drawn immediately before the IV's 16 — the same construction as the IV, so the framer draws 12). Kotlin: the pinned production seal (`CpimShaTailSeal` — SHA-256 via the platform, sig via the ported `spimMapSignature`) is the provider default; 195 tests green. — 2026-10-08 (rev 30, clean-room RE of the NAC mint — the validation blob "C5" — over the same unstripped Linux `.so`; gdb oracle quadruples first, then python model, then Kotlin; method + findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the mint is local and pure, and every byte of the 517-B validation stamp is now derived EXCEPT one residue (below). The stamp = `0x02 ‖ rand16 (RNG) ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`; blob480 = `tag 0x05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79`, where cert79 is the first 79 B of the ctx cert chain and session250 the 250-B session slice — E2E the full stamp computes byte-exact from (cert79, session250, rng_pad130, body576, rand16). The crypto layers, all byte-exact vs three independent live runs: **pear_aes** — a white-box AES variant (`create_rounds` = AES-128-style expansion with pluggable sbox/rcon; `init_key` = S1-scramble → schedule; `establish_key` = schedule + T-transform of blocks 1–9 only, blocks 0/10 raw; `encrypt_cbc` = whitening + **9 rounds** + final `SE[st9[p]]^rk11` with p=[12,10,4,3,15,5,2,8,14,1,9,7,0,13,11,6]; `decrypt_cbc` = backward rounds with the key xor fused into the table index, final `perm(SDI[st9^rk1])^chain^rk0`); **domergestep2** — the white-box core of `scramble_body` (KP key schedule over 80 B, 4 blocks of the `0x51·m` constant with state[0] xored on EVERY block, final `TC[x]+k`, out = state ⊕ in1; 21/21 live captures); **key_establishment** — the EstablishKeyResponse wire is `tag ‖ key16@0x01 ‖ u32be bodyLen@0x11 ‖ body@0x15 (0x250) ‖ trailing (85 B, unused by the crypto)`. **SignState::sign** (the 16-B OTS signature over the blob): structure fully decoded — scatter → polynomial chain → flag table → u32 permutations → divisor table → key map → keygen → matrix/phases B–F → 16 position rounds → tail (fold chains + threshold cipher + staging + final formula); stages 1–9 are hand-transcribed and byte-exact vs ground truth, the tail's threshold cipher (AES-like, 9 rounds × 30 generator runs) is structurally decoded with 270 checkpointed rounds, and the signature the model produces is byte-exact vs the live stamp. CLOSED (same day, follow-up): the capture-free pure-code transcription of the tail cipher and the pre-init region — the full 517-B stamp now computes byte-exact from (cert79, session250, rng_pad130, body576, rand16) in a pure-Python model (no emulator, no captures; `sig_hand.py verify` 20/20) with the complete constant inventory recorded for the Kotlin port (see WORKLOG session 20). Kotlin: `registration` `PearTablesData`/`PearTables` (generated base64 table image, ClearAdiTablesData pattern), `PearAes`, `NacMerge`, `NacValidation` (`mint` + `keyEstablishment`; sig16 a parameter — no placeholder signature), 206 tests green (synthetic vectors, no Apple bytes). — 2026-10-08 (rev 31, Kotlin port of the sign model — the sig16 residue above is CLOSED): `SignState::sign` is transcribed to `registration` `NacSign` (full pipeline: scatter → u32 flag table → perms → divisor/key map → keygen → matrix/phases B–E → 16 position rounds, then the 30-run tail — RS32/rec0/r70ab init, run-start feedback, soup57/soup80, the 9-round threshold cipher, staging from the generator soup, final formula, chain1 fold), with its .rodata tables embedded as a generated base64 image (`NacSignTablesData`/`NacSignTables`, PearTablesData pattern; the 17-loop byte tables are in-range slices of the T2_BIG span). `NacValidation.mint(cert79, session250, rngPad130, rand16, body576)` now computes the full 517-B stamp including sig16 internally (the sig16-parameter assembly step remains as `mintWithSig`); Kotlin sign == python model on LCG-seeded synthetic vectors (incl. zero-rand16 and zero-blob edges), full-mint e2e byte-exact, 208 tests green. ### 1.2 Activation endpoints and certificates @@ -331,6 +331,7 @@ Ordered by value. IDs match the inline `TODO(capture):` markers above. ## Revision history +- Rev 31 (2026-10-08, Kotlin port of the sign model — the rev-30 sig16 residue is CLOSED; method in `registration/dev/clearadi/captures/NAC-NOTES.md`, constant inventory in `STAGE7-10-REPORT.md` session 6): `SignState::sign` is transcribed to Kotlin `registration` `NacSign` (full pipeline — scatter → u32 flag table → perms → divisor/key map → keygen → matrix/phases B–E → 16 position rounds, then the 30-run tail: RS32/rec0/r70ab init, run-start feedback, soup57/soup80, the 9-round threshold cipher, staging from the generator soup, final formula, chain1 fold), byte-exact vs the pure-Python model on LCG-seeded synthetic vectors incl. edge inputs, with the .rodata tables embedded as a generated base64 image (`NacSignTablesData`/`NacSignTables`, PearTablesData pattern; the 17-loop byte tables are in-range slices of the T2_BIG span, no duplicate embedding). `NacValidation.mint(cert79, session250, rngPad130, rand16, body576)` now computes the full 517-B stamp including sig16 internally (assembly-with-sig kept as `mintWithSig`); full-mint e2e test byte-exact vs the python-generated vector. 208 tests green (synthetic vectors only, no Apple bytes). - Rev 30 (2026-10-08, clean-room RE of the NAC mint — the validation blob "C5" — gdb oracle + python model + Kotlin; method/findings in `registration/dev/clearadi/captures/NAC-NOTES.md`): the 517-B validation stamp is fully derived — stamp = `0x02 ‖ rand16 ‖ sig16 ‖ u32be(0x1e0) ‖ blob480`, blob480 = `05 ‖ u32be(1) ‖ u32be(0x180) ‖ scramble_body(session250, rng_pad130) ‖ u64be(79) ‖ cert79` — with pear_aes (white-box AES variant: 9-round CBC, custom whitening/final maps, pluggable sbox schedules, establish_key T-transform on blocks 1–9), domergestep2 (21/21 live captures) and key_establishment (EstablishKeyResponse wire `tag ‖ key16@1 ‖ u32be len@0x11 ‖ body@0x15 ‖ 85-B trailing`) byte-exact vs three independent live runs, and the full stamp computed byte-exact end-to-end from (cert79, session250, rng_pad130, body576, rand16). SignState::sign (the 16-B OTS) is structurally decoded with stages 1–9 hand-verified; the tail threshold cipher is checkpointed (270 rounds) and CLOSED the same day via an empirical fit against those checkpoints — the capture-free pure-Python model now computes the full 517-B stamp byte-exact from its inputs, with the constant inventory recorded for the Kotlin port (the Kotlin signature port is the next step). Kotlin `PearTables`/`PearAes`/`NacMerge`/`NacValidation`; 206 tests green. - Rev 29 (2026-10-07, continuation capture — two further live OpenBubbles provisioning runs under gdb, `gdb_prov8/9.gdb`): the cpim's X group is fully pinned — X = SHA-256(encout ‖ spim_map_signature(trailing[0:16]) ‖ a fixed 24-byte .rodata filler constant, digest byte-exact on the wire — closing the X32, 12-B-plaintext-tail (12 fresh RNG bytes, same pool construction as the IV) and trailing[0:16] (the signature input) TODOs; the "constant sig block" reading is corrected (it was a stale session's trailing head) and "sig16/digest not on the wire" is resolved (both ride transitively through X). Kotlin `CpimShaTailSeal` wired as the production default; 195 tests green. - Rev 28 (2026-10-07, live capture — one real OpenBubbles provisioning run under gdb over the unstripped Linux `.so`; dumps + method in `registration/dev/clearadi/captures/WIRE-NOTES.md`): the §1.1 anisette framer is corrected on every point the previous session left `TODO(capture)`. The cpim is an OUTER 276-B message `[u32be(5)][iv 16][u32be(160)][encout 160][X 32][u32be(52)][u32be(4)][Y 52]` over a 160-B plaintext; the PTM is `[u32 BE 4][seed 16][u32 BE payloadLen][payload]` with the seed riding into decryptPTM as its chain seed; ProvisionedData = `{metadata Vec (400 B), client_secret = rng2 (32 B), mid = rng3 (60 B), flavor u8}` with the finish gate = the decrypt output's out[408:440] == rng1 echo; the spim carries 99 trailing bytes (the ≤23-B cap was a probe artifact) and trailing[16:76] is relayed verbatim as the wire tail's `Y` group. Superseded readings recorded dead: the 'IV from Spim trailing fields' (it is the thread-RNG pool), the 'two 256-bit sig/sha tail fields' (neither the spim_map_signature output nor the SHA-256 digest appears on the wire), and the OTP-path ProvisionedMachine mid/secret ordering. Remaining `TODO(capture)`: the X32 source, the 12-B plaintext tail, trailing[0:16]. Kotlin `ClearAdiFraming`/`ClearAnisetteProvider` restructured to the live shapes; 194 tests green. diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacMint.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacMint.kt new file mode 100644 index 0000000..48832b1 --- /dev/null +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacMint.kt @@ -0,0 +1,28 @@ +package dev.fenn.imessage.registration + +/** + * Public facade over the internal NAC mint ([NacValidation], spec §1.1 rev 31 — the 517-B + * validation stamp, byte-exact vs the live captures): the consumer-visible mint surface for + * the §1.1 validation-data seam (:engine api-exposes :registration, but internal members + * stay module-private). + * + * Pure math — no transport, no persistence. The mapping from the pinned §1.1 exchange to + * these inputs is NOT established (§1.1 C56 residue; NAC-NOTES.md closes only the math): + * callers must not fabricate cert79/session250/rngPad130/body576/pearKey16 — run the + * exchange and fail loudly at the first unestablished mapping instead. + */ +object NacMint { + + /** [NacValidation.mint] — the full 517-B stamp; sig16 computed internally from body576/rand16/blob480. */ + fun mint( + cert79: ByteArray, + session250: ByteArray, + rngPad130: ByteArray, + rand16: ByteArray, + body576: ByteArray, + ): ByteArray = NacValidation.mint(cert79, session250, rngPad130, rand16, body576) + + /** [NacValidation.keyEstablishment] — the SDAT-mapped EstablishKeyResponse wire. */ + fun keyEstablishment(sessionInfo: ByteArray, pearKey16: ByteArray): ByteArray = + NacValidation.keyEstablishment(sessionInfo, pearKey16) +} diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt new file mode 100644 index 0000000..99eeeb9 --- /dev/null +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSign.kt @@ -0,0 +1,797 @@ +package dev.fenn.imessage.registration + +/** + * Kotlin transcription of SignState::sign (0x179de50, open_absinthe::nac NAC mint "C5" — the + * 16-byte signature over the 480-byte validation body), from the byte-exact pure-Python models + * sig_hand.py / sig_init.py / sig_tail.py (NAC-NOTES.md; STAGE7-10-REPORT.md session 6: + * e2e verified against the live stamp, 270/270 base + 225/225 mod tail rounds, `sig_hand.py + * verify` 20/20). Tables come from [NacSignTables]; state-embedded constants (region 0x6f98, + * 0x6fd8 selectors, 0x6fe8 mask/C68, P table) were runtime constants of the binary, verified + * input- and body-independent. + * + * Pipeline: static state build (stages 1–9: scatter, u32 flag table, perms, divisor, key map, + * keygen, matrix copy + phases B–E, 16 position rounds) with the input mapped in (rand16 at + * state+0x15f0, blob480 at state+0x1600), then the 30-run tail — per run: RS32/rec0/r70ab init, + * run-start feedback, soup57/soup80, 9 threshold-cipher rounds (r70ab ^= soup after rounds 3/7), + * staging from the generator soup, final formula, and the chain1 fold with tmp. sig16 = the 30th + * final-formula output. + * + * The N constant (scatter size 2571 and the RS-init index modulo) is the model's pinned value — + * byte-faithful to the verified Python. + */ +internal object NacSign { + + /** SignState::sign -> the 16-byte sig16. blob480 must be exactly 480 bytes. */ + internal fun sign(body576: ByteArray, rand16: ByteArray, blob480: ByteArray): ByteArray { + require(blob480.size == 480) { "sign: blob480 must be exactly 480 bytes, got ${blob480.size}" } + val bs = buildState(body576, rand16, blob480) + val state = bs.state + var chain1 = IntArray(16) { i -> + foldStep(rand16[i].toInt() and 0xff, blob480[i].toInt() and 0xff) + } + var tmp = ByteArray(16) + for (run in 0 until 30) { + val (rs, r0, r70ab) = rsInit(state, bs.bufs, chain1) + val region = NacSignTables.region6f98 + val ts = TailState(rs, r0, r70ab, intArrayOf( + region[4].toInt() and 0xff, region[5].toInt() and 0xff, + region[7].toInt() and 0xff, region[10].toInt() and 0xff)) + runstartFeedback(ts, rs[16], rs[12]) + // [rsp+0x80] is re-seeded per run with chain1[10] — no cross-run chaining + val s = soup(state, chain1, chain1[10], chain1[7], chain1[4]) + var sp20 = 0 + for (r12 in 0..8) { + val sp = cipherRound(ts, state, r12) + if (r12 == 3) ts.r70ab = s.first xor 0x9b + else if (r12 == 7) ts.r70ab = s.second xor 0x9b + if (r12 == 8) sp20 = sp + } + for (i in rs.indices) state[0x6ff0 + i] = rs[i].toByte() + for (i in ts.rec.indices) state[0x7001 + i] = ts.rec[i].toByte() + state[0x70ab] = ts.r70ab.toByte() + val stg = stagingFromSoup(state, bs.vecB, bs.n, sp20) + tmp = finalFormula(stg, state) + if (run < 29) { + chain1 = IntArray(16) { i -> + foldStep(tmp[i].toInt() and 0xff, blob480[16 * (run + 1) + i].toInt() and 0xff) + } + } + } + return tmp + } + + // ---------------------------------------------------------------- state -- + + private class BuiltState( + val state: ByteArray, + val bufs: Array, + val vecB: ByteArray, + val n: Int, + ) + + /** Static state (0x7888 B) + derived pieces for one sign() call (sig_init.build_state). */ + private fun buildState(body: ByteArray, rand16: ByteArray, blob480: ByteArray): BuiltState { + val t = NacSignTables + val state = ByteArray(0x7888) + val u32t = u32tab() + val (perm1, perm2) = perms(u32t) + for (i in 0..255) putU32le(state, 0x21d8 + 4 * i, perm2[i]) + for (i in 0..255) putU32le(state, 0x1dd8 + 4 * i, perm1[i]) + putU64le(state, 0x17e0, N.toLong()) + val kbmap = mapKey(divisor(body)) + kbmap.copyInto(state, 0x1be8) + val kg = keygen(body, kbmap) + kg.copyInto(state, 0x2678) + phaseBCDE(body, kbmap, u32t, state) + val (n, _, vecA, vecB) = vecABMut(body, u32t) + rounds(state) + t.region6f98.copyInto(state, 0x6f98) + t.sel6fd8.copyInto(state, 0x6fd8) + t.maskC68.copyInto(state, 0x6fe8) + t.pTable.copyInto(state, 0x6898) + rand16.copyInto(state, 0x15f0) + blob480.copyInto(state, 0x1600) + val bufs = genBufs(state.copyOfRange(0x2678, 0x2678 + 544), vecA) + return BuiltState(state, bufs, vecB, n) + } + + // ------------------------------------------------- stage 1: scatter ------ + + private fun scatter(body: ByteArray): Pair { + val n = (((body[202].toInt() xor body[250].toInt()) and 0xff) shl 8) or + ((body[195].toInt() xor body[243].toInt()) and 0xff) + val buf = ByteArray(n) + for (i in 0 until n) { + buf[i] = body[(3 * (body[i % 576].toInt() and 0xff) + i + 2) % 576] + } + return n to buf + } + + // ------------------------- stage 3: flags u32 table (state+0x17e8) ------ + + private val C0 = 0xb4b41272.toInt() + private val CFL = intArrayOf( + 0x89e23c5f.toInt(), 0xc74c4a03.toInt(), 0xb8f43515.toInt(), 0x07297e18, + 0xf2cc1c57.toInt(), 0x292bcf40, 0xe863df66.toInt(), 0x8aa0b814.toInt(), + ) + + private fun u32tab(): IntArray { + val t = IntArray(256) + for (b in 0..255) { + var v = C0 + for (i in 0..7) { + if (b and (1 shl i) != 0) v = v xor CFL[i] + } + t[b] = v + } + return t + } + + // ------------- stages 4/5: divisor+map (state+0x1be8) ------------------- + + private val B4 = intArrayOf(0x00, 0x14, 0x28, 0x46) + + private fun divisor(body: ByteArray): ByteArray { + val div = ByteArray(176) + for (i in 0..15) { + val q = i shr 2 + val b = B4[i and 3] + val row = ByteArray(11) + for (c in 0..3) { + val x = (body[0x30 + 4 * c + q].toInt() xor body[0xe0 + 4 * c + q].toInt()) and 0xff + row[c] = (x % (b + 7) and 3).toByte() + } + for (c in 0..3) { + val x = (body[0xf0 + 4 * c + q].toInt() xor body[0x30 + 4 * c + q].toInt()) and 0xff + row[4 + c] = (x % (b + 9) and 3).toByte() + } + for (c in 0..2) { + val x = (body[0xc0 + 4 * c + q].toInt() xor body[0x30 + 4 * c + q].toInt()) and 0xff + row[8 + c] = (x % (b + 5) and 3).toByte() + } + row.copyInto(div, 11 * i) + } + return div + } + + private fun step(kb: Int): Int = when (kb) { + 1 -> 5 + 0x18 -> 3 + 0x24 -> 1 + else -> error("bad key byte ${kb.toString(16)}") + } + + private fun mapKey(div: ByteArray): ByteArray { + val km = div.copyOf() + for (c in 0..10) { + var acc = 0 + for (r in 0..15) { + when (val v = km[11 * r + c].toInt() and 0xff) { + in 0..1 -> { km[11 * r + c] = 0x18; acc += 3 } + 2 -> { km[11 * r + c] = 0x01; acc += 5 } + else -> { km[11 * r + c] = 0x24; acc += 1 } + } + } + var k = 0 + while (acc > 32) { // exit when acc <= 0x20 + val row = (12 + 5 * k) and 0xf + when (km[11 * row + c].toInt() and 0xff) { + 0x01 -> { acc -= 4; km[11 * row + c] = 0x24 } + 0x18 -> { acc -= 2; km[11 * row + c] = 0x24 } + } + k += 1 + } + } + return km + } + + // ------------------------- stage 6: perm tables ------------------------- + + private fun perms(u32t: IntArray): Pair { + val tA = NacSignTables.tA + val tB = NacSignTables.tB + val tC = NacSignTables.tC + val perm1 = IntArray(256) + val perm2 = IntArray(256) + for (i in 0..255) { + val t = u32t[i] + val s = (tB[(tA[i].toInt() xor 0xa4) and 0xff].toInt() and 0xff) + perm1[s] = t + val u = (tC[i].toInt() xor tB[i].toInt()) and 0xff + perm2[u] = t + } + return perm1 to perm2 + } + + // ----------- stage 7: keygen (544 B at state+0x2678) -------------------- + + private fun keygen(body: ByteArray, kbmap: ByteArray): ByteArray { + val t = NacSignTables + val out = ByteArray(544) + var acc = 0 + for (o in 0..8) { + val chunk = t.e16[o] + val skip = t.skip[o] + val rowOff = 0x200 * o + var cum = 0 + for (c in 0..15) { + val kb = kbmap[1 + o + 11 * c].toInt() and 0xff + val stp = step(kb) + val rbp = skip + cum + val i1 = (acc + rbp) % 576 + val i2 = (skip + 1 + cum + i1) % 576 + val bSum = (body[i1].toInt() + body[i2].toInt()) and 0xff + val gi = (t.tG[c].toInt() and 0xff) + chunk + out[gi] = bSum.toByte() + var p1 = 0 + for (k in 0 until stp) { + p1 = p1 xor ((t.tbl9[rowOff + 0x20 * c + ((cum + k) and 0xf)].toInt() and 0xff)) + } + var p2 = 0 + for (k in 0 until stp) { + p2 = p2 xor (body[rbp + k].toInt() and 0xff) + } + out[gi + 1] = (((p1 xor p2) - bSum) and 0xff).toByte() + acc = i2 + cum += stp + } + } + return out + } + + // ----------- stage 8: matrix copy + phases B..E ------------------------- + + private val FLAGS = 0xa4b51a62.toInt() // state+0x6fec constant + + private fun phaseBCDE(body: ByteArray, kbmap: ByteArray, u32t: IntArray, state: ByteArray) { + val t = NacSignTables + for (j in 0..13) { + val src = (t.mtxSrc[j] * 16).toInt() + val dst = t.mtxDst[j].toInt() + body.copyInto(state, 0x2678 + dst, src, src + 16) + } + var pos = 0 + for (j in 0..15) { // phase B: kb row state+0x1bf2 + val kb = kbmap[0x0a + 11 * j].toInt() and 0xff + val s = step(kb) + if (kb != 0x24) { + var x = 0 + for (k in 0 until s) { + x = x xor ((body[0x1a0 + pos + k].toInt() and 0xff) xor + (t.phbT[0x20 * j + ((pos + k) and 0xf)].toInt() and 0xff)) + } + putU32le(state, 0x1d98 + 4 * t.phbIdx[j].toInt(), FLAGS xor u32t[x]) + } + pos += s + } + for (j in 0..15) { // phase C: kb == 0x24 of same row + val kb = kbmap[0x0a + 11 * j].toInt() and 0xff + if (kb == 0x24) { + val dst = 0x1d98 + 4 * t.phbIdx[j].toInt() + for (b in 0..3) { + state[dst + b] = ((state[0x27b8 + 4 * j + b].toInt() xor + state[0x2758 + (4 * j and 0xc) + b].toInt()) and 0xff).toByte() + } + } + } + pos = 0 + for (j in 0..15) { // phase D + val kb = kbmap[11 * j].toInt() and 0xff + val s = step(kb) + if (kb != 0x24) { + var x = 0 + for (k in 0 until s) { + x = x xor ((body[0x40 + pos + k].toInt() and 0xff) xor + (t.pheT[0x20 * j + ((pos + k) and 0xf)].toInt() and 0xff)) + } + putU32le(state, 0x1c98 + 4 * t.pheIdx[j].toInt(), u32t[x]) + } + pos += s + } + for (j in 0..15) { // phase E: kb == 0x24 rows of row B + val kb = kbmap[11 * j].toInt() and 0xff + if (kb == 0x24) { + val off = j + (if (j < 5) 0 else if (j < 13) 1 else 2) + val dst = 0x1c98 + 4 * t.pheIdx[j].toInt() + for (b in 0..3) { + state[dst + b] = ((state[0x2768 + 4 * off + b].toInt() xor + state[0x2758 + 4 * (off and 3) + b].toInt()) and 0xff).toByte() + } + } + } + fun f(x: Int, b: Int): Int = (((x or 0xf0) + 0xf0) and FMASK[b]) and 0xff + for (a in 0 until 0x24 step 4) { + for (k in 0..3) { + var w = 0 + for (b in 0..3) { + w = w or (((state[0x2678 + f(a + 0x24 * k + b, b)].toInt() and 0xff) xor + (state[0x2768 + 0x24 * k + a + b].toInt() and 0xff)) shl (8 * b)) + } + putU32le(state, 0x25d8 + 4 * (a + k), w) + } + } + var rcx = 7; var rdx = 0; var rsi = 2 + for (i in 0..15) { + val r8 = 2 * i + val r9 = (rcx and 0xf) + 0xa1 - (r8.inv() and 2) + val idx1 = (r9 and 0x2f) xor 0x231 + val idx2 = (((rsi and 0xf) + ((rdx and 6) xor 2) + 0x1d) and 0xef) xor 0x23 + val bl = (state[0x2678 + idx1].toInt() xor state[0x2678 + (r9 xor 0xa1)].toInt()) and 0xff + val b2 = (state[0x2678 + (idx2 or 0x210)].toInt() xor state[0x2748 + idx2].toInt()) and 0xff + state[0x2668 + i] = (bl - b2 and 0xff).toByte() + rcx += 3; rdx += 6; rsi += 0xb + } + } + + private val FMASK = intArrayOf(0xec, 0xed, 0xee, 0xff) + + // ----------- stage 9: vecA/vecB + 16 position rounds -------------------- + + private val C68 = 0xa4b51a62.toInt() // scatter-mutation index const + private val MUT_MASK = 0xeffef7ef.toInt() + + private fun scatterMutated(body: ByteArray, u32t: IntArray): Pair { + val (n, scat) = scatter(body) + val buf = scat.copyOf() + var d = 0xb0 + for (i in 0..255) { + val idx = (((u32t[i] xor C0) xor C68).toLong() and MUT_MASK.toLong() and 0xffffffffL) + .rem(n.toLong()).toInt() + buf[idx] = (d xor 0xb0).toByte() + val r10 = (2 * (i + 1)) and 0xff + d = (((0xa0 - (r10 and 0x60)) or 0x11) + i) and 0xff + } + return n to buf + } + + private fun vecABMut(body: ByteArray, u32t: IntArray): Quad { + val t = NacSignTables + val (n, scat) = scatterMutated(body, u32t) + val vecA = ByteArray(n) + val vecB = ByteArray(n) + for (i in 0 until n) { + val s = scat[i].toInt() and 0xff + vecA[i] = ((t.t243c50[s].toInt() xor t.t243d50[s].toInt()) and 0xff).toByte() + val pre = ((i.inv() shr 1) and 0xe6) + (i shr 2) + 0xd + vecB[i] = ((pre and 0xff) xor + (t.tB[(t.t243b50[s].toInt() xor 0xa4) and 0xff].toInt() and 0xff) xor 0x82).and(0xff) + .toByte() + } + return Quad(n, scat, vecA, vecB) + } + + private class Quad(val first: A, val second: B, val third: C, val fourth: D) { + operator fun component1(): A = first + operator fun component2(): B = second + operator fun component3(): C = third + operator fun component4(): D = fourth + } + + private fun rounds(state: ByteArray) { + val t2 = NacSignTables.t2Big + val perm2u = IntArray(256) { u32At(state, 0x21d8 + 4 * it) } + for (p in 0..15) { + val r13 = 4 * (p and 3) or (p shr 2) + val seedA = ((((state[0x2888 + r13].toInt() xor state[0x2878 + r13].toInt()) and 0xff) + + (state[0x2888 + r13].toInt() xor state[0x2748 + r13].toInt())) and 0xff) xor 0x38 + var r8 = 0xa71f8a3b.toInt() + val baseW = 0x2898 + 0x1000 * (p and 3) + 0x400 * (p shr 2) + val t2b = 0x1400 * (p and 3) + 0x500 * (p shr 2) + for (j in 0 until 128) { + val x1 = t2[t2b + 2 * j].toInt() and 0xff + putU32le(state, baseW + 8 * j, + (r8 + 0x4fd1152d) xor perm2u[x1 xor seedA] xor 0x12501000) + val x2 = t2[t2b + 2 * j + 1].toInt() and 0xff + putU32le(state, baseW + 8 * j + 4, r8 xor perm2u[x2 xor seedA] xor 0x12501000) + r8 += 0x605dd5a6 + } + // (the per-round vecout is recomputed by genBufs from the same table) + } + } + + // ----------- 16 generator buffers (sig_init.gen_bufs) ------------------- + + private fun genBufs(kg: ByteArray, vecA: ByteArray): Array { + val t2 = NacSignTables.t2Big + val out = arrayOfNulls(16) + for (iter in 0..15) { + val q = iter shr 2 + val r = iter and 3 + val rbx = 13 * q + 4 * r + val sel = rbx and 0xf + val raxPre = (rbx and 0xf) + ((0x1e - 2 * rbx) and 0x16) + 0x15 + val i1 = raxPre xor 0x2b + val i2 = (raxPre and 0x2f) xor 0xfb + val seed = (((kg[i1].toInt() xor kg[0x140 + i2].toInt()) and 0xff) - + ((kg[0x140 + i2].toInt() xor kg[i2].toInt()) and 0xff) and 0xff) xor 0x59 + val entry = q + 4 * r + val tblOff = 0x9000 + sel * 256 + val buf = ByteArray(vecA.size) + for (i in vecA.indices) { + buf[i] = ((((i xor 0x73) + 0xc5) and 0xff) xor + (t2[tblOff + ((vecA[i].toInt() and 0xff) xor seed)].toInt() and 0xff) xor 0x89) + .and(0xff).toByte() + } + out[entry] = buf + } + @Suppress("UNCHECKED_CAST") + return out as Array + } + + // ----------- per-run init: RS32, rec0, r70ab (sig_init.rs_init) --------- + + private const val N = 2571 + private val MASK_IDX = 0xeffef7ef.toInt() + + /** RS byte template: perm1[c] ^ PDE[k] -> masked index -> BUF lookup. */ + private fun rsIdxVal(c: Int, k: Int, state: ByteArray, buf: ByteArray): Int { + val w = u32At(state, 0x1dd8 + 4 * c) xor u32At(state, 0x1d98 + 4 * k) + // w & MASK_IDX is an unsigned u32 in the model — keep it unsigned here too + var idx = (w.toLong() and MASK_IDX.toLong() and 0xffffffffL) + if (idx >= N) idx %= N + val i = idx.toInt() + return ((((i and 0xff) xor 0xf3) + 0x45) and 0xff) xor + (buf[i].toInt() and 0xff) xor 0x89 + } + + private fun rec0Of(chain1: IntArray): ByteArray = + ByteArray(17) { j -> (((chain1[(3 + 7 * j) % 16] + j) and 0xff) xor 0x58).toByte() } + + /** per r8: (tsel, k, dst); buffer = generator entry r8+4. */ + private val LOOP = arrayOf( + intArrayOf(4, 13, 16), intArrayOf(1, 7, 11), intArrayOf(14, 14, 13), + intArrayOf(11, 1, 14), intArrayOf(8, 11, 9), intArrayOf(5, 4, 0), + intArrayOf(2, 10, 5), intArrayOf(15, 0, 12), intArrayOf(12, 15, 8), + intArrayOf(9, 12, 3), intArrayOf(6, 2, 10), intArrayOf(3, 3, 2), + ) + + /** single blocks: (dst, c, k, entry). */ + private val SINGLES = arrayOf( + intArrayOf(1, 0, 5, 0), intArrayOf(4, 13, 6, 1), + intArrayOf(6, 10, 9, 2), intArrayOf(15, 7, 8, 3), + ) + + private fun rsInit( + state: ByteArray, + bufs: Array, + chain1: IntArray, + ): Triple { + val rs = IntArray(32) + for ((r8, l) in LOOP.withIndex()) { + val (tsel, k, dst) = listOf(l[0], l[1], l[2]) + rs[dst] = rsIdxVal(chain1[tsel], k, state, bufs[r8 + 4]) + } + for (s in SINGLES) { + val (dst, c, k, entry) = listOf(s[0], s[1], s[2], s[3]) + rs[dst] = rsIdxVal(chain1[c], k, state, bufs[entry]) + } + val r0 = rec0Of(chain1) + // r70ab from chain1 + vec16 (0x17a297d block) + var al = ((chain1[0] xor 0xf2) + (state[0x2668 + 2].toInt() and 0xff) - + (state[0x2668].toInt() and 0xff)) and 0xff + al = al xor chain1[1] + var cl = (chain1[2] - (state[0x2668 + 11].toInt() and 0xff)) and 0xff + cl = (cl + al) and 0xff + cl = cl xor (state[0x2668 + 12].toInt() and 0xff) + cl = (cl - chain1[3]) and 0xff + return Triple(rs, r0, cl xor 0x9b) + } + + // ----------- soup57/soup80 (0x17a2f1a-0x17a2fc5) ------------------------ + + private fun soup( + state: ByteArray, + chain1: IntArray, + sp80In: Int, + r10b: Int, + r11b: Int, + ): Pair { + val g = NacSignTables.region6f98 + val c = chain1 + val dl = ((c[8] xor 5) + (g[9].toInt().inv() and 0xff) + (g[8].toInt() and 0xff)) and 0xff + var cl = ((dl * 2 + 2).inv() and 0xcc) + dl + 0x9b and 0xff + cl = (cl xor c[9]) xor 0x99 + var r8b = sp80In + r8b = (r8b - (g[13].toInt() and 0xff)) and 0xff + r8b = (r8b + cl) and 0xff + r8b = r8b xor (g[15].toInt() and 0xff) + r8b = (r8b + (c[11] xor 0x7f)) and 0xff + r8b = (r8b + 0x81) and 0xff + var r11 = ((r11b xor 0xf4) - (g[6].toInt() and 0xff) + (g[1].toInt() and 0xff)) and 0xff + r11 = (r11 xor c[5]) and 0xff + var r9 = (c[6] + 0x80) and 0xff + r9 = (r9 - (g[3].toInt() and 0xff)) and 0xff + r9 = (r9 + r11) and 0xff + r9 = r9 xor (g[14].toInt() and 0xff) + r9 = (r9 + 0x80) and 0xff + r9 = (r9 - r10b) and 0xff + return r9 to r8b + } + + // ----------- threshold cipher tail (sig_tail.py) ------------------------ + + private class TailState(rs32: IntArray, rec0: ByteArray, var r70ab: Int, sp20Consts: IntArray) { + val rs = rs32.copyOf() + val rec = IntArray(17 * 9) + val c97c = sp20Consts[0] + val c97d = sp20Consts[1] + val c97f = sp20Consts[2] + val c9a2 = sp20Consts[3] + + init { + for (i in 0..16) rec[i] = rec0[i].toInt() and 0xff + } + } + + /** run-start feedback (0x17a2eac): bl = a ^ b ^ RS[1] -> RS[7]; RS[3] ^= bl ^ 0x38. */ + private fun runstartFeedback(ts: TailState, a: Int, b: Int) { + val bl = (a and 0xff) xor (b and 0xff) xor ts.rs[1] + ts.rs[7] = bl + ts.rs[3] = ts.rs[3] xor bl xor 0x38 + } + + private fun mix(kg: (Int) -> Int, rbp: Int, rs: IntArray, al: Int, bl: Int): Map { + val r = rs + val g = { j: Int -> kg(rbp + j) } + val x = { a: Int, b: Int -> (a xor b) and 0xff } + return mapOf( + "dl1" to x(x(g(0x0e) + g(0x0f), r[0x0b]), 0x38), + "dil1" to x(g(0x0c) + g(0x0d), r[0x0a]), + "dil1x" to (x(g(0x0c) + g(0x0d), r[0x0a]) xor 0x38), + "r8b" to x(x(g(0x06) + g(0x07), r[0x10]), 0x38), + "al" to x(x(g(0x04) + g(0x05), r[0x00]), 0x38), + "b6" to x(x(g(0x00) + g(0x01), r[0x08]), 0x38), + "bl" to x(x(bl, al), (g(0x14) + g(0x15)) and 0xff), + "r12b" to x(x(g(0x1a) + g(0x1b), r[0x04]), 0x38), + "r11b" to x(x(g(0x12) + g(0x13), r[0x09]), 0x38), + "cl3" to x(x(g(0x18) + g(0x19), r[0x0d]), 0x38), + "edi2" to x(x(g(0x08) + g(0x09), r[0x06]), 0x38), + "r10b" to x(x(g(0x16) + g(0x17), r[0x05]), 0x38), + "r13mid" to x(x(g(0x10) + g(0x11), r[0x02]), 0x38), + "dl2" to x(x(g(0x1e) + g(0x1f), r[0x0f]), 0x38), + "bpl" to x(x(g(0x1c) + g(0x1d), r[0x0c]), 0x38), + "sp1f8" to x(x(g(0x0a) + g(0x0b), r[0x01]), 0x38), + "sp48" to x(x(g(0x02) + g(0x03), r[0x0e]), 0x38), + ) + } + + // round constants (rc-xor at 0x17a347b): (ecx, ebx, eax, edx) per r12. + private val RC = arrayOf( + intArrayOf(0x6db4d78c, 0x39c17123, 0x10000800, 0x7d2b7a3d), + intArrayOf(0x91c9e17b.toInt(), 0x43c27516, 0x8833bd3f.toInt(), 0x2be7e3f8), + intArrayOf(0xc5c95c16.toInt(), 0x3600f2eb, 0x4b150d7f, 0x1e1561a0), + intArrayOf(0x9d272c48.toInt(), 0xff511567.toInt(), 0xf52b2b67.toInt(), 0xc974d62c.toInt()), + intArrayOf(0xc21d8753.toInt(), 0x533fd05b, 0x253d787c, 0xc1481826.toInt()), + intArrayOf(0xd7915485.toInt(), 0xf959e065.toInt(), 0x3e03b158, 0x07d5db45), + intArrayOf(0xfd338a1f.toInt(), 0x8a4a0677.toInt(), 0xf2cc1c47.toInt(), 0x0a536e6c), + intArrayOf(0x935aec40.toInt(), 0x596dbe37, 0x647bccd7, 0x6c2bb938), + intArrayOf(0x6cede063, 0x23361c77, 0xa0cee083.toInt(), 0x4b8b7e10), + ) + + /** r14b after mixing: constant per r12; record-window byte offset in the export D formula. */ + private val XR14 = intArrayOf(0, 1, 1, 2, 2, 2, 5, 3, 3) + + /** 17-loop byte-table pointers (sig_tail._BT_PTRS) — slices of t2Big (base 0x2279f8). */ + private val BT_PTRS = intArrayOf( + 0x22b9f8, 0x22bef8, 0x22c3f8, 0x22c8f8, 0x22cdf8, 0x22d2f8, 0x22d7f8, 0x22dcf8, + 0x22e1f8, 0x22e6f8, 0x22ebf8, 0x22f0f8, 0x22f5f8, 0x22faf8, 0x22fff8, 0x2304f8, + 0x22f9f8, 0x22fef8, 0x2303f8, 0x2308f8, 0x227df8, 0x2282f8, 0x2287f8, 0x228cf8, + 0x2291f8, 0x2296f8, 0x229bf8, 0x22a0f8, 0x22a5f8, 0x22aaf8, 0x22aff8, 0x22b4f8, + 0x22a9f8, 0x22aef8, 0x22b3f8, 0x22b8f8, 0x22bdf8, 0x22c2f8, 0x22c7f8, 0x22ccf8, + 0x22d1f8, 0x22d6f8, 0x22dbf8, 0x22e0f8, 0x22e5f8, 0x22eaf8, 0x22eff8, 0x22f4f8, + 0x22e9f8, 0x22eef8, 0x22f3f8, 0x22f8f8, 0x22fdf8, 0x2302f8, 0x2307f8, 0x227cf8, + 0x2281f8, 0x2286f8, 0x228bf8, 0x2290f8, 0x2295f8, 0x229af8, 0x229ff8, 0x22a4f8, + 0x2299f8, 0x229ef8, 0x22a3f8, 0x22a8f8, 0x22adf8, 0x22b2f8, 0x22b7f8, 0x22bcf8, + 0x22c1f8, 0x22c6f8, 0x22cbf8, 0x22d0f8, 0x22d5f8, 0x22daf8, 0x22dff8, 0x22e4f8, + 0x22d9f8, 0x22def8, 0x22e3f8, 0x22e8f8, 0x22edf8, 0x22f2f8, 0x22f7f8, 0x22fcf8, + 0x2301f8, 0x2306f8, 0x227bf8, 0x2280f8, 0x2285f8, 0x228af8, 0x228ff8, 0x2294f8, + 0x2289f8, 0x228ef8, 0x2293f8, 0x2298f8, 0x229df8, 0x22a2f8, 0x22a7f8, 0x22acf8, + 0x22b1f8, 0x22b6f8, 0x22bbf8, 0x22c0f8, 0x22c5f8, 0x22caf8, 0x22cff8, 0x22d4f8, + 0x22c9f8, 0x22cef8, 0x22d3f8, 0x22d8f8, 0x22ddf8, 0x22e2f8, 0x22e7f8, 0x22ecf8, + 0x22f1f8, 0x22f6f8, 0x22fbf8, 0x2300f8, 0x2305f8, 0x227af8, 0x227ff8, 0x2284f8, + ) + + private fun btabAt(t2: ByteArray, r12: Int, tsel: Int, idx: Int): Int { + val ptr = BT_PTRS[r12 * 16 + tsel] - 0x2279f8 + return t2[ptr + idx].toInt() and 0xff + } + + /** One cipher round; returns sp20 (only meaningful for r12 == 8). Mutates ts. */ + private fun cipherRound(ts: TailState, state: ByteArray, r12: Int): Int { + val t = NacSignTables + val t2 = t.t2Big + val kg = { off: Int -> state[0x2678 + off].toInt() and 0xff } + val rbp = t.sel[r12].toInt() + val rs = ts.rs + val al = rs[3] + val bl = rs[7] + val m = mix(kg, rbp, rs, al, bl) + val utab = { slot: Int, idx: Int -> t.utab[r12][slot][idx] } + val ebp = utab(1, m["r12b"]!!) xor utab(0, m["sp1f8"]!!) + var eax = utab(1, m["al"]!!) xor utab(0, m["r11b"]!!) xor + utab(2, m["r10b"]!!) xor utab(3, m["bpl"]!!) + var ecx = utab(3, m["dl2"]!!) xor utab(2, m["edi2"]!!) + val edi = utab(5, m["dl1"]!!) xor utab(4, m["r8b"]!!) + val r10 = utab(5, m["bl"]!!) xor utab(4, m["b6"]!!) + var ebx = utab(7, m["sp48"]!!) xor utab(6, m["cl3"]!!) + var edx = utab(7, m["r13mid"]!!) xor utab(6, m["dil1x"]!!) + ecx = ecx xor ebp xor RC[r12][0] + ebx = ebx xor edi xor RC[r12][1] + eax = eax xor RC[r12][2] + edx = edx xor r10 xor RC[r12][3] + // export + val x14 = XR14[r12] + val d = ts.r70ab xor ts.rec[17 * x14 + 16] xor ts.rec[17 * x14 + 8] xor + m["dil1"]!! xor ((ebx shr 16) and 0xff) xor 0x5c + val exp = IntArray(17) + exp[0] = ((ecx shr 16) and 0xff) xor d + exp[1] = ebx and 0xff + exp[2] = (ecx shr 8) and 0xff + exp[3] = (eax shr 24) and 0xff + exp[4] = (edx shr 8) and 0xff + exp[5] = (ebx shr 8) and 0xff + exp[6] = (ebx shr 16) and 0xff + exp[7] = (edx shr 16) and 0xff + exp[8] = d + exp[9] = (eax shr 8) and 0xff + exp[10] = eax and 0xff + exp[11] = (ecx shr 24) and 0xff + exp[12] = edx and 0xff + exp[13] = (edx shr 24) and 0xff + exp[14] = (ebx shr 24) and 0xff + exp[15] = (eax shr 16) and 0xff + exp[16] = ecx and 0xff + for (i in 0..14) rs[17 + i] = exp[i] + var sp20 = 0 + if (r12 < 8) { + for (i in 0..16) ts.rec[17 * (r12 + 1) + i] = exp[i] + for (i in 0..16) { + if (i == 8) continue + var v = btabAt(t2, r12, t.ts17[i].toInt(), exp[i] xor (if (i == 0) d else 0)) + if (t.md17[i].toInt() == 3) v = v xor 0x38 + rs[t.md17[i].toInt()] = v + } + val bl2 = rs[11] xor rs[4] xor ts.r70ab xor rs[1] xor 0x64 + rs[7] = bl2 + rs[3] = rs[3] xor bl2 + } else { + var v = exp[12] xor 0x1c + v = (v - ts.c97c + ts.c9a2) and 0xff + v = v xor exp[13] // 'xor %dil' + v = (v + ((ts.c97f - exp[14]) and 0xff)) and 0xff // 'sub %bl' + v = v xor ts.c97d + v = (v + exp[15]) and 0xff // 'add %al' + sp20 = v + } + for (i in 0..16) ts.rec[i] = exp[i] + return sp20 + } + + // ----------- staging from the generator soup (sig_hand) ----------------- + + private const val MASK6FE8 = 0x10010810 + private const val SP28 = 0x40 + + private fun stagingFromSoup( + state: ByteArray, + vecB: ByteArray, + n: Int, + sp20: Int, + ): ByteArray { + val t = NacSignTables + val t2 = t.t2Big + val stg = ByteArray(16) + for (i in 0..15) { + val idxP = (t.t2Sel[i] shr 2).toInt() // phaseD/E u32 index (<= 0xff) + var ebx = state[0x7001 + t.t1Sel[i].toInt()].toInt() and 0xff + if (i == 10) ebx = ebx xor (state[0x7009].toInt() and 0xff) + val rdx = (0x100 * (i and 3)) or ebx + val r9 = ebx * 0x4fd1152d + 0x890f6097.toInt() + val r10 = u32At(state, 0x1c98 + 4 * idxP) + val p2u = u32At(state, 0x21d8 + 4 * (state[0x6f98 + i].toInt() and 0xff)) + val edi: Int + val ebp: Int + when (i) { + in 0..3 -> { edi = u32At(state, 0x2898 + 4 * rdx); ebp = p2u } + 4, 5 -> { edi = u32At(state, 0x3898 + 4 * rdx); ebp = p2u } + 6, 7 -> { edi = p2u; ebp = u32At(state, 0x3898 + 4 * rdx) } + 8, 9 -> { edi = u32At(state, 0x4898 + 4 * rdx); ebp = p2u } + 10 -> { edi = u32At(state, 0x21d8 + 4 * ebx); ebp = u32At(state, 0x21d8) } + 11 -> { edi = p2u; ebp = u32At(state, 0x4898 + 4 * rdx) } + else -> { edi = u32At(state, 0x5898 + 4 * rdx); ebp = p2u } + } + val ecx = r10 xor 0x4b2270b0 + val b0 = MASK6FE8 and edi + val r12v = ecx and MASK6FE8 + val r8v = MASK6FE8 and ebp + val out: Int + if (i == 10) { + // al source captured live = st[0x7009] ^ idx (head xor at 0x17a374a) + var al = (state[0x7009].toInt() xor + state[0x7001 + t.t1Sel[10].toInt()].toInt()) and 0xff + al = (al xor sp20) and 0xff + val r10x = u32At(state, 0x5098 + 4 * ebx) + val eax = u32At(state, 0x21d8 + 4 * al) xor r10x xor + u32At(state, 0x21d8 + 4 * (sp20 and 0xff)) xor r9 xor 0x6dafefff + val ecx2 = u32At(state, 0x21d8 + 4 * SP28) + val edi2 = edi xor ebp xor r10 xor b0 xor r8v xor r12v xor ecx2 xor eax + out = edi2 xor (((eax xor ecx2) xor 0x4b2270b0) and MASK6FE8) + } else { + val r15n = MASK6FE8 and (r9 xor 0x268d9f4f) + val edi2 = edi xor r15n + val ebp2 = ebp xor r9 xor ecx xor edi2 + out = (b0 xor r12v xor ebp2 xor r8v) xor 0x268d9f4f + } + val v = (out.toLong() and 0xffffffffL) % n + stg[i] = (((v shr 2).toInt() xor (vecB[v.toInt()].toInt() and 0xff) xor 0x71) and 0xff) + .toByte() + } + return stg + } + + // ----------- final formula (0x17a3f80) ---------------------------------- + + private fun finalFormula(stg: ByteArray, state: ByteArray): ByteArray { + val t = NacSignTables + val out = ByteArray(16) + for (i in 0..15) { + val sel = state[0x6fd8 + i].toInt() and 0xff + val b = t.fin[sel].toInt() // u64 <= 0x1ff (bounds-checked) + val a = stg[i].toInt() and 0xff + val r = when { + a == 0 -> b and 0xff + b == a -> 0 + else -> keygenCommon1(a, b) + } + out[i] = (((r - (state[0x6898 + 0x100 * sel + a].toInt() and 0xff) + 0xeb) and 0xff) + xor 0x7f).toByte() + } + return out + } + + // ----------- keygen_common1 (0x179dd60) + fold quirks ------------------- + + /** keygen_common1 @0x179dd60: rdi=a, rsi=b -> al. */ + private fun keygenCommon1(a: Int, b: Int): Int { + val t = NacSignTables + val v1 = (t.k1[a].toInt() xor 0xa4) and 0xff + val v2 = (t.k1[b].toInt() xor 0xa4) and 0xff + val t1 = if (v1 < 0x1b) 0x100 else 0 + val t2 = if (v2 < 0x1b) 0x100 else 0 + val r8 = ((if (v1 >= 0x1b) 0x100 else 0) + v1 - 0x100) xor 0xff + val i1 = v2 + t2 + r8 + check(i1 in 0 until 0x200) { "keygen_common1: i1 out of range" } + val v3 = (t.k2[i1].toInt() xor 0xa4) and 0xff + val t3 = if (v3 < 0x49) 0x100 else 0 + val i2 = t3 + v1 + t1 + v3 - 0x64 + check(i2 in 0 until 0x200) { "keygen_common1: i2 out of range" } + return t.k3[i2].toInt() and 0xff + } + + /** caller-side fold quirks (0x179dd60 call sites). */ + private fun foldStep(prev: Int, x: Int): Int = when { + prev == 0 -> x + x == 0 -> prev + prev == x -> 0 + else -> keygenCommon1(x, prev) + } + + // ----------- little-endian state helpers -------------------------------- + + private fun u32At(b: ByteArray, off: Int): Int = + (b[off].toInt() and 0xff) or + ((b[off + 1].toInt() and 0xff) shl 8) or + ((b[off + 2].toInt() and 0xff) shl 16) or + ((b[off + 3].toInt() and 0xff) shl 24) + + private fun putU32le(b: ByteArray, off: Int, v: Int) { + b[off] = v.toByte() + b[off + 1] = (v shr 8).toByte() + b[off + 2] = (v shr 16).toByte() + b[off + 3] = (v shr 24).toByte() + } + + private fun putU64le(b: ByteArray, off: Int, v: Long) { + for (i in 0 until 8) b[off + i] = (v shr (8 * i)).toByte() + } +} diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt new file mode 100644 index 0000000..d476305 --- /dev/null +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTables.kt @@ -0,0 +1,108 @@ +package dev.fenn.imessage.registration + +/** + * Static .rodata tables of the SignState::sign NAC-mint path (librust_lib_bluebubbles), embedded + * as base64 source in [NacSignTablesData] (no Apple-derived binary ships in the repo) and decoded + * once at first use. Names follow the verified Python models (sig_hand.py/sig_tail.py/sig_init.py); + * the vaddr in each member's doc cites the source location in the .so. Word tables are stored + * little-endian (the x86 memory image). State-embedded constants (region6f98/sel6fd8/maskC68/ + * pTable) were runtime constants of the binary, verified input- and body-independent. + */ +internal object NacSignTables { + private val bins: List = listOf( + java.util.Base64.getMimeDecoder().decode(NacSignTablesData.signChunks0.joinToString("")), + java.util.Base64.getMimeDecoder().decode(NacSignTablesData.signChunks1.joinToString("")), + ) + + private fun bytesAt(img: Int, off: Int, n: Int): ByteArray = + bins[img].copyOfRange(off, off + n) + + private fun u16sAt(img: Int, off: Int, n: Int): IntArray = IntArray(n) { i -> + val p = off + 2 * i + (bins[img][p].toInt() and 0xff) or ((bins[img][p + 1].toInt() and 0xff) shl 8) + } + + private fun wordsAt(img: Int, off: Int, n: Int): IntArray = IntArray(n) { i -> + val p = off + 4 * i + (bins[img][p].toInt() and 0xff) or + ((bins[img][p + 1].toInt() and 0xff) shl 8) or + ((bins[img][p + 2].toInt() and 0xff) shl 16) or + ((bins[img][p + 3].toInt() and 0xff) shl 24) + } + + private fun longsAt(img: Int, off: Int, n: Int): LongArray = LongArray(n) { i -> + var v = 0L + for (b in 7 downTo 0) v = (v shl 8) or (bins[img][off + 8 * i + b].toLong() and 0xff) + v + } + + /** .rodata 0x1a10f0 — 544 B. */ + val tG: ByteArray by lazy { bytesAt(0, 0, 544) } + /** .rodata 0x2251d8 — 72 B. */ + val sel: LongArray by lazy { longsAt(1, 0, 72 / 8) } + /** .rodata 0x225220 — 256 B. */ + val tB: ByteArray by lazy { bytesAt(1, 72, 256) } + /** .rodata 0x225320 — 256 B. */ + val tA: ByteArray by lazy { bytesAt(1, 328, 256) } + /** .rodata 0x225420 — 256 B. */ + val tC: ByteArray by lazy { bytesAt(1, 584, 256) } + /** .rodata 0x225a98 — 512 B. */ + val k1: ByteArray by lazy { bytesAt(1, 840, 512) } + /** .rodata 0x225c98 — 512 B. */ + val k2: ByteArray by lazy { bytesAt(1, 1352, 512) } + /** .rodata 0x225e98 — 512 B. */ + val k3: ByteArray by lazy { bytesAt(1, 1864, 512) } + /** .rodata 0x226098 — 128 B. */ + val phbIdx: LongArray by lazy { longsAt(1, 2376, 128 / 8) } + /** .rodata 0x226118 — 512 B. */ + val phbT: ByteArray by lazy { bytesAt(1, 2504, 512) } + /** .rodata 0x226318 — 56 B. */ + val fin: LongArray by lazy { longsAt(1, 3016, 56 / 8) } + /** .rodata 0x22635b — 512 B. */ + val pheT: ByteArray by lazy { bytesAt(1, 3072, 512) } + /** .rodata 0x226560 — 128 B. */ + val pheIdx: LongArray by lazy { longsAt(1, 3584, 128 / 8) } + /** .rodata 0x2265e0 — 4608 B. */ + val tbl9: ByteArray by lazy { bytesAt(1, 3712, 4608) } + /** .rodata 0x2277e0 — 112 B. */ + val mtxSrc: LongArray by lazy { longsAt(1, 8320, 112 / 8) } + /** .rodata 0x227850 — 112 B. */ + val mtxDst: LongArray by lazy { longsAt(1, 8432, 112 / 8) } + /** .rodata 0x2278c0 — 18 B. */ + val e16: IntArray by lazy { u16sAt(1, 8544, 18 / 2) } + /** .rodata 0x2278d2 — 18 B. */ + val skip: IntArray by lazy { u16sAt(1, 8562, 18 / 2) } + /** .rodata 0x2278f8 — 128 B. */ + val t1Sel: LongArray by lazy { longsAt(1, 8580, 128 / 8) } + /** .rodata 0x227978 — 128 B. */ + val t2Sel: LongArray by lazy { longsAt(1, 8708, 128 / 8) } + /** .rodata 0x2279f8 — 40960 B. */ + val t2Big: ByteArray by lazy { bytesAt(1, 8836, 40960) } + /** per-round u32 T-tables (sig_tail.UTAB), 9 rounds x 8 slots x 256. */ + val utab: Array> by lazy { + Array(9) { r12 -> Array(8) { slot -> + wordsAt(1, utabOffs[r12 * 8 + slot], 256) + } } + } + private val utabOffs = intArrayOf( + 82564, 106116, 55940, 79492, 103044, 52868, 76420, 99972, 115332, 65156, 88708, 112260, 62084, 85636, 109188, 59012, 74372, 97924, 121476, 71300, 94852, 118404, 68228, 91780, 107140, 56964, 80516, 104068, 53892, 77444, 100996, 50820, 66180, 89732, 113284, 63108, 86660, 110212, 60036, 83588, 98948, 122500, 72324, 95876, 119428, 69252, 92804, 116356, 57988, 81540, 105092, 54916, 78468, 102020, 51844, 75396, 90756, 114308, 64132, 87684, 111236, 61060, 84612, 108164, 49796, 73348, 96900, 120452, 70276, 93828, 117380, 67204, + ) + /** .rodata 0x243a40 — 136 B. */ + val ts17: LongArray by lazy { longsAt(1, 123524, 136 / 8) } + /** .rodata 0x243ac8 — 136 B. */ + val md17: LongArray by lazy { longsAt(1, 123660, 136 / 8) } + /** .rodata 0x243b50 — 256 B. */ + val t243b50: ByteArray by lazy { bytesAt(1, 123796, 256) } + /** .rodata 0x243c50 — 256 B. */ + val t243c50: ByteArray by lazy { bytesAt(1, 124052, 256) } + /** .rodata 0x243d50 — 256 B. */ + val t243d50: ByteArray by lazy { bytesAt(1, 124308, 256) } + /** embedded constant — 16 B. */ + val region6f98: ByteArray by lazy { bytesAt(1, 124564, 16) } + /** embedded constant — 16 B. */ + val sel6fd8: ByteArray by lazy { bytesAt(1, 124580, 16) } + /** embedded constant — 8 B. */ + val maskC68: ByteArray by lazy { bytesAt(1, 124596, 8) } + /** embedded constant — 1792 B. */ + val pTable: ByteArray by lazy { bytesAt(1, 124604, 1792) } +} diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt new file mode 100644 index 0000000..c54af3c --- /dev/null +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacSignTablesData.kt @@ -0,0 +1,167 @@ +package dev.fenn.imessage.registration + +/** + * GENERATED FILE — regenerate with /tmp/clearadi-re/gen_nac_sign_tables.py (session 21); do not + * hand-edit. The SignState::sign (NAC mint C5) white-box .rodata tables (librust_lib_bluebubbles), + * embedded as base64 source so no Apple-derived binary ships in the repo: 2 images of + * the tables consumed by [NacSignTables] (sig_hand.py/sig_tail.py/sig_init.py models), each + * concatenated in vaddr order (split at large vaddr gaps). [NacSignTables] decodes them once at + * first use; raw dev copies stay under registration/dev/clearadi/ (gitignored) for byte-level + * cross-checks. + * + * Image layout (126940 bytes, 102 entries): + tG: vaddr 0x1a10f0, image 0, offset 0, 544 B (b) + sel: vaddr 0x2251d8, image 1, offset 0, 72 B (u64) + tB: vaddr 0x225220, image 1, offset 72, 256 B (b) + tA: vaddr 0x225320, image 1, offset 328, 256 B (b) + tC: vaddr 0x225420, image 1, offset 584, 256 B (b) + k1: vaddr 0x225a98, image 1, offset 840, 512 B (b) + k2: vaddr 0x225c98, image 1, offset 1352, 512 B (b) + k3: vaddr 0x225e98, image 1, offset 1864, 512 B (b) + phbIdx: vaddr 0x226098, image 1, offset 2376, 128 B (u64) + phbT: vaddr 0x226118, image 1, offset 2504, 512 B (b) + fin: vaddr 0x226318, image 1, offset 3016, 56 B (u64) + pheT: vaddr 0x22635b, image 1, offset 3072, 512 B (b) + pheIdx: vaddr 0x226560, image 1, offset 3584, 128 B (u64) + tbl9: vaddr 0x2265e0, image 1, offset 3712, 4608 B (b) + mtxSrc: vaddr 0x2277e0, image 1, offset 8320, 112 B (u64) + mtxDst: vaddr 0x227850, image 1, offset 8432, 112 B (u64) + e16: vaddr 0x2278c0, image 1, offset 8544, 18 B (u16) + skip: vaddr 0x2278d2, image 1, offset 8562, 18 B (u16) + t1Sel: vaddr 0x2278f8, image 1, offset 8580, 128 B (u64) + t2Sel: vaddr 0x227978, image 1, offset 8708, 128 B (u64) + t2Big: vaddr 0x2279f8, image 1, offset 8836, 40960 B (b) + utab[8][0]: vaddr 0x2319f8, image 1, offset 49796, 1024 B (u32) + utab[3][7]: vaddr 0x231df8, image 1, offset 50820, 1024 B (u32) + utab[6][6]: vaddr 0x2321f8, image 1, offset 51844, 1024 B (u32) + utab[0][5]: vaddr 0x2325f8, image 1, offset 52868, 1024 B (u32) + utab[3][4]: vaddr 0x2329f8, image 1, offset 53892, 1024 B (u32) + utab[6][3]: vaddr 0x232df8, image 1, offset 54916, 1024 B (u32) + utab[0][2]: vaddr 0x2331f8, image 1, offset 55940, 1024 B (u32) + utab[3][1]: vaddr 0x2335f8, image 1, offset 56964, 1024 B (u32) + utab[6][0]: vaddr 0x2339f8, image 1, offset 57988, 1024 B (u32) + utab[1][7]: vaddr 0x233df8, image 1, offset 59012, 1024 B (u32) + utab[4][6]: vaddr 0x2341f8, image 1, offset 60036, 1024 B (u32) + utab[7][5]: vaddr 0x2345f8, image 1, offset 61060, 1024 B (u32) + utab[1][4]: vaddr 0x2349f8, image 1, offset 62084, 1024 B (u32) + utab[4][3]: vaddr 0x234df8, image 1, offset 63108, 1024 B (u32) + utab[7][2]: vaddr 0x2351f8, image 1, offset 64132, 1024 B (u32) + utab[1][1]: vaddr 0x2355f8, image 1, offset 65156, 1024 B (u32) + utab[4][0]: vaddr 0x2359f8, image 1, offset 66180, 1024 B (u32) + utab[8][7]: vaddr 0x235df8, image 1, offset 67204, 1024 B (u32) + utab[2][6]: vaddr 0x2361f8, image 1, offset 68228, 1024 B (u32) + utab[5][5]: vaddr 0x2365f8, image 1, offset 69252, 1024 B (u32) + utab[8][4]: vaddr 0x2369f8, image 1, offset 70276, 1024 B (u32) + utab[2][3]: vaddr 0x236df8, image 1, offset 71300, 1024 B (u32) + utab[5][2]: vaddr 0x2371f8, image 1, offset 72324, 1024 B (u32) + utab[8][1]: vaddr 0x2375f8, image 1, offset 73348, 1024 B (u32) + utab[2][0]: vaddr 0x2379f8, image 1, offset 74372, 1024 B (u32) + utab[6][7]: vaddr 0x237df8, image 1, offset 75396, 1024 B (u32) + utab[0][6]: vaddr 0x2381f8, image 1, offset 76420, 1024 B (u32) + utab[3][5]: vaddr 0x2385f8, image 1, offset 77444, 1024 B (u32) + utab[6][4]: vaddr 0x2389f8, image 1, offset 78468, 1024 B (u32) + utab[0][3]: vaddr 0x238df8, image 1, offset 79492, 1024 B (u32) + utab[3][2]: vaddr 0x2391f8, image 1, offset 80516, 1024 B (u32) + utab[6][1]: vaddr 0x2395f8, image 1, offset 81540, 1024 B (u32) + utab[0][0]: vaddr 0x2399f8, image 1, offset 82564, 1024 B (u32) + utab[4][7]: vaddr 0x239df8, image 1, offset 83588, 1024 B (u32) + utab[7][6]: vaddr 0x23a1f8, image 1, offset 84612, 1024 B (u32) + utab[1][5]: vaddr 0x23a5f8, image 1, offset 85636, 1024 B (u32) + utab[4][4]: vaddr 0x23a9f8, image 1, offset 86660, 1024 B (u32) + utab[7][3]: vaddr 0x23adf8, image 1, offset 87684, 1024 B (u32) + utab[1][2]: vaddr 0x23b1f8, image 1, offset 88708, 1024 B (u32) + utab[4][1]: vaddr 0x23b5f8, image 1, offset 89732, 1024 B (u32) + utab[7][0]: vaddr 0x23b9f8, image 1, offset 90756, 1024 B (u32) + utab[2][7]: vaddr 0x23bdf8, image 1, offset 91780, 1024 B (u32) + utab[5][6]: vaddr 0x23c1f8, image 1, offset 92804, 1024 B (u32) + utab[8][5]: vaddr 0x23c5f8, image 1, offset 93828, 1024 B (u32) + utab[2][4]: vaddr 0x23c9f8, image 1, offset 94852, 1024 B (u32) + utab[5][3]: vaddr 0x23cdf8, image 1, offset 95876, 1024 B (u32) + utab[8][2]: vaddr 0x23d1f8, image 1, offset 96900, 1024 B (u32) + utab[2][1]: vaddr 0x23d5f8, image 1, offset 97924, 1024 B (u32) + utab[5][0]: vaddr 0x23d9f8, image 1, offset 98948, 1024 B (u32) + utab[0][7]: vaddr 0x23ddf8, image 1, offset 99972, 1024 B (u32) + utab[3][6]: vaddr 0x23e1f8, image 1, offset 100996, 1024 B (u32) + utab[6][5]: vaddr 0x23e5f8, image 1, offset 102020, 1024 B (u32) + utab[0][4]: vaddr 0x23e9f8, image 1, offset 103044, 1024 B (u32) + utab[3][3]: vaddr 0x23edf8, image 1, offset 104068, 1024 B (u32) + utab[6][2]: vaddr 0x23f1f8, image 1, offset 105092, 1024 B (u32) + utab[0][1]: vaddr 0x23f5f8, image 1, offset 106116, 1024 B (u32) + utab[3][0]: vaddr 0x23f9f8, image 1, offset 107140, 1024 B (u32) + utab[7][7]: vaddr 0x23fdf8, image 1, offset 108164, 1024 B (u32) + utab[1][6]: vaddr 0x2401f8, image 1, offset 109188, 1024 B (u32) + utab[4][5]: vaddr 0x2405f8, image 1, offset 110212, 1024 B (u32) + utab[7][4]: vaddr 0x2409f8, image 1, offset 111236, 1024 B (u32) + utab[1][3]: vaddr 0x240df8, image 1, offset 112260, 1024 B (u32) + utab[4][2]: vaddr 0x2411f8, image 1, offset 113284, 1024 B (u32) + utab[7][1]: vaddr 0x2415f8, image 1, offset 114308, 1024 B (u32) + utab[1][0]: vaddr 0x2419f8, image 1, offset 115332, 1024 B (u32) + utab[5][7]: vaddr 0x241df8, image 1, offset 116356, 1024 B (u32) + utab[8][6]: vaddr 0x2421f8, image 1, offset 117380, 1024 B (u32) + utab[2][5]: vaddr 0x2425f8, image 1, offset 118404, 1024 B (u32) + utab[5][4]: vaddr 0x2429f8, image 1, offset 119428, 1024 B (u32) + utab[8][3]: vaddr 0x242df8, image 1, offset 120452, 1024 B (u32) + utab[2][2]: vaddr 0x2431f8, image 1, offset 121476, 1024 B (u32) + utab[5][1]: vaddr 0x2435f8, image 1, offset 122500, 1024 B (u32) + ts17: vaddr 0x243a40, image 1, offset 123524, 136 B (u64) + md17: vaddr 0x243ac8, image 1, offset 123660, 136 B (u64) + t243b50: vaddr 0x243b50, image 1, offset 123796, 256 B (b) + t243c50: vaddr 0x243c50, image 1, offset 124052, 256 B (b) + t243d50: vaddr 0x243d50, image 1, offset 124308, 256 B (b) + region6f98: vaddr embedded, image 1, offset 124564, 16 B (b) + sel6fd8: vaddr embedded, image 1, offset 124580, 16 B (b) + maskC68: vaddr embedded, image 1, offset 124596, 8 B (b) + pTable: vaddr embedded, image 1, offset 124604, 1792 B (b) + */ +internal object NacSignTablesData { + /** sign tables image 0, base64, 1 chunk(s) — concatenate in order. */ + val signChunks0: List = listOf( + "DR0LIQkRGwUVBxkfAxcPEz4ycIJStLaFUbV8EHBjQ9ugtHNOHLikryaCnhJgPJyzaw+alRDZ669c1jbGMZHVAK3X5kPktZaPEzStLAv+PoXwCQTtGdonj5iveg7WJ2F0b0ehTD+DDDNeNOjUfW7hjzAxMjM0NTY3ODlBQkNERUY69J0n7Slocv5MrLcFHwhXIHdoZW4gZXhwZWN0aW5nIEJvZHlXcml0ZUFib3J0ZWQAAAAAAAAAAAQAAAAAAAAA/////w2AAPwBAAB4AQAAuC8x7N8YvCoW+dbt7nTrtqj96AAgMB4wCAYGKoUDAgIJMjU1MTkgY29sbGlzaW9uc1VVVVVVVVVVVVVVVVVVVVVzZW50ZW5jZXRlcm1pbmFsYAsBAHILAQB4CwEAfwsBAIAIAQCeCAEApwgBAK8IAQByaW5nX2NpcmNsZV90eXBlaWNlU2Vjb25kYXJ5QXV0aERpZCBjaXJjbGUgc3RlcCAta2V5AAAAAAAAAAAAAAAATG9nU3BlY2lmaWNhdGlvbkFzc2V0R2V0UmVzcG9uc2VkAAAAAAAAAAAAAAAAAAAATm8gcmVjb3JkIGZvdW5kP0Nsb3VkUGFydGljaXBhbnRfGQ64GLniSynFj4/cNUZddHJ1bmNhdGVkX2tleV9pZHNvZnR3YXJlX3ZlcnNpb25nZXRfMmZhX3Ntc19vcHRzVHJhbnNjcmlwdER5bmFtaQ==", + ) + /** sign tables image 1, base64, 43 chunk(s) — concatenate in order. */ + val signChunks1: List = listOf( + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "LiwyMCYkKiguLDIwpqSqqK6ssrCmpKqorqyysKakqqiurLKwpqSqqK6ssrCmpKqorqyysKakqqiurLKwpqSqqK6ssrCmpKqorqyysCYkKiguLDIwJiQqKC4sMjAmJCooLiwyMCYkKiguLDIwJiQqKC4sMjAmJCooLiwyMCYkKiguLDIwJiQqKC4sMjCusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqiusK6wpqimqK6wrrCmqKaorrCusKaopqguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYoLjAuMCYoJiguMC4wJigmKC4wLjAmKCYo", + ) +} diff --git a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacValidation.kt b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacValidation.kt index 2400ca3..2192e18 100644 --- a/registration/src/main/kotlin/dev/fenn/imessage/registration/NacValidation.kt +++ b/registration/src/main/kotlin/dev/fenn/imessage/registration/NacValidation.kt @@ -4,8 +4,7 @@ package dev.fenn.imessage.registration * NAC validation stamp assembly (ValidationCtx::sign / ValidationCtx::key_establishment, * open_absinthe::nac, librust_lib_bluebubbles): the deku wire layouts of ValidationBody / * ValidationData and the EstablishResponse parse, transcribed from the byte-exact models - * (nac_mint.py + NAC-NOTES.md). SignState::sign's output arrives as a parameter (sig16) — - * that sub-step is modeled separately and deliberately not stubbed here. + * (nac_mint.py + NAC-NOTES.md). sig16 is computed internally via [NacSign] (SignState::sign). */ internal object NacValidation { @@ -38,8 +37,27 @@ internal object NacValidation { return stamp } - /** ValidationCtx::sign: the 517-byte validation stamp (sig16 supplied by the caller). */ + /** + * ValidationCtx::sign: the full 517-byte validation stamp. body576 is ValidationCtx + * [0x40:0x2c0] (the sign() body input); sig16 = SignState::sign(body576, rand16, blob480) + * with blob480 = the ValidationBody wire built here (NAC-NOTES.md; verified byte-exact, + * STAGE7-10-REPORT.md session 6). + */ internal fun mint( + cert79: ByteArray, + session250: ByteArray, + rngPad130: ByteArray, + rand16: ByteArray, + body576: ByteArray, + ): ByteArray { + val scrambled = NacMerge.scrambleBody(session250, rngPad130) + val blob = bodyToBits(scrambled, cert79) + val sig16 = NacSign.sign(body576, rand16, blob) + return dataToBits(rand16, sig16, blob) + } + + /** Stamp assembly with the signature supplied (the blob-assembly step of the mint). */ + internal fun mintWithSig( cert79: ByteArray, session250: ByteArray, rngPad130: ByteArray, diff --git a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt new file mode 100644 index 0000000..cd12621 --- /dev/null +++ b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacSignTest.kt @@ -0,0 +1,70 @@ +package dev.fenn.imessage.registration + +import kotlin.test.Test +import kotlin.test.assertContentEquals + +/** + * Synthetic LCG-seeded vectors for the SignState::sign port ([NacSign]); expected sig16 values + * generated by the verified Python model (sig_hand.py sign_sig16 — session 21; see WORKLOG). + * Inputs: LCG(1103515245, 12345, little-endian dwords) — no capture-derived bytes. + */ +class NacSignTest { + + private class SignVector( + val label: String, + val body576: String, + val rand16: String, + val blob480: String, + val sig16: String, + ) + + private val vectors = listOf( + SignVector( + "lcg-101", + "3a213df3eb01039e489b9f58e13df5be06174c04c7d10d58f423b77a1dd7a6cf929d02fd63c30b77608b1c8719c8de65de00295dbf326d328cfdae7cd5cc0a0eea4cc0c6db3b4c1e786614075161b8f3b64dcec8b7ba48ac247265648dc1d013428fe98a534b24de908c99f989e994568e5d85a5af491e86bce1b2c14595594d9ac4fd32cbd10f31a85daa83c1400310669063e5a7bf479654ac1b7bfd274276f24c08ad43af2629c039b1dff9468ea83e46ca3b9ffc7a28ec315077b559e3c44a882071bbc39c47d880041f31dc3c1316dfe67a97e049cd84d2acf66d0ad205a2d6e93633ef41c4f092669b69e01101eeba32218f4ba2991ceeb99c251a5fa7fa9713dbab11024508d08518a1338c24c639f316871d4ed6b4e4ab29dd6817b5522cd974230b650520987c95d9b526659ebbb99b7f36731f4c16e3e395d643c3aaf3819b9bbb0e6e384b51ce1147d80276a0e363777613f4e4e26bb14d4369ca024ee1db13033f1c5049766d49c793a94e481ae66fbd8cb57caa7ee1058fc8f25a9bd65d8bc1515968f249ed8116c8742613d3d867eb181714cdffa5bd99de4fb23bcdb903d73e0280a69629b914e0e2fe60cfdf5fe04dfdacaaff3c7543e48b0a8f3cfe7b231adf98c512a1f1a1c2b8d6919c69577c9dcd44a33aca2d6c4e8362f527e5f386936ab0afe066299e52d5ae0514bd4f9fd52ddc1699e0e5f34dd0bace9e396be17609c8c40ec461e9eef4861cdb364729a0337465afbb9dba4f46127b3c6de3122cb2e06417899963f2645e36e3b63ffa02040cef3d2955a07c5d", + "a76f0335549ca560fd571dd9f2bcfbac", + "0500000001000001809daa70106844a654fa12bc8259e24e389238f0bf2a97cec941169a1432f8ad22bfa4909dedb5f489f94012be765a21d3e7866d85940d5410c4b06224a967f2361839cd9ab0db9291a569ffec988ee3c98ebf3f37602a64c60640a8a13eab708a953bb7ac4904c82af566d0b54ba8edabe4518e92e4c9bde6acef7ad9e42839c2f6cc25c9e63e8835df144f5c5e0cb1150d02c27395caea75dacd2d2d4b6f051e7828190e4bed710cbe6f70ccfd7786c83b0665da666c0150bd20a27bf2406515632c6f3416c1bfc2ab8ef5f68bf8af0f4bb80a2f880d9c32e32bc55c5fd5855af1258c5796be3542c422404abea395d99d886612c0490092683bcfaf3c6cd1a9356ce2097bbba51ad832877864082b0765f7a87c8e528f728919336b54a61f1b942b7a9713d936dd0f16ca3c06e04717bd1f656a1e8db1c1bb7fddde5b5e6b7eeb9e7982799cf0cb1a772946bf2482591fcf1ab046cdb3fb035930d6ba71c2645aeed76d3c2c381092624df9fa5e063d77f9970551a6c5280fe263f9ddc1de29000000000000004f14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a", + "deb0d8abb9ee3f6c9d5cd696955b66db", + ), + SignVector( + "lcg-2024", + "013edc07a6e470a9e71e208994bac1b93db9cd0032a536c883c2455c00ec493f39ac61007ee22599df0398eb2cc8613ef5d2a7588aa83940fbfea24e183b391671a9efb256c311f4d78f983fc4f01267ad6b04a4e2be7e637352ecff3055b0f0a91529482ee7cde7cfa2afea5c947deb6563d4a23a48d58feb9cadd0489a7dc8e1d02c3e06aebfcfc71c47faf412f6031d9a444692a4986163be0e6b606adb7619bb151cde7798a2bfdd24c38cccfc52d5ef3d1cea333079db9653da7825f0b551b47a15b6a4d58fb7c5eaf02421be7e8d44e5aa42568f7053065c12902b4ed2899cee9d8e9440cdafb49605bc70927a45781bbc9a6bb500cbec23e7a8dc730cc15380ec66a76e94a78a0249541b7e80fd6afd98f2d32d57432a4374c0984baaf9b93a6f3e3d41509f276428ec80b1bab5fc63354aef8f9bbb9e6df4d8bfabb831afa42e16b665fa976bcd058401099d6d0d644ba21dffa4332af308f0b1d67c69134121ee71d5a88f36ac771cfd8cee257dce66fabeaadfabac3f7108cffa95a1c60e6fc6d0554b87684af8b4d3f182dd2bb0e052334e6223065b322077b2ced9a808a59e32f8987fe14d054ce517a495f9d1caaadab0339b16692e380a849e119aa5d876f7992d778138afe4918b2b4dc638cb021526c013be292c50e8615b497a58bb4e7f64d76f28e8987c39054c0572a5e75a420d7f8bdc784e68712a1b8129109e262a4d1467b61667143ce90abddc1441b2c251c80352cefb80052845b987b764fe5795bf5f0bda9facf9c76975e63fbf0af6ead97bfebd35980491d3", + "6e8ca2490f7f136c9cdb9d09a539c8a7", + "050000000100000180b49fc061af5995307c3ed10a68f4212659e46cdc5cb722990345f480d8e9a8cd20e35a29f0927843abc203406811fbfa85c028cbd136008ec4d13eb4aca51f960f0f5ed28846f5315f81d9d88defcab9fce5482a928a15a020cccbdec6d9c43c813e5541ab9f362c566e24b72a28ed5ddc7b8e3f825beeace225f1f2e6b0510f8c80bf1483ca21365e4305c32260f5bc6364f219e68a2bc7066a4fba9d4ce81dd6ecebc1b8192a3176b06f0d3cc74f21be344d9bf0c9bbbbdc3b74ad66f6d16b2812d16da3e09fe5f84b3ddf11da0aa3c8097aceeab1fa939c5b4d10ccf7954191be29ddbbc38137d558b43e234a5a7fcb904aae0df34fee751cf4fbfb0a932f3c6d0ab1e664a8e309e5ae28dccdf889f7a7b1449d877bae3b8934eda6f69d319a55ff1ddc7cad6bc4637e6e532dba7aefe7bc914bbfb8b7af9c23c5d395c4ade7a5e57e8a2f6122b1214f993e4186cd088b86e70bff38742bc486e5fd72c080247e990beaacd8e0e2e20ca03cf428062b14d62151256b24ea3d8730f9bcd41c000000000000004fdbda688b7819b62e51981b8ab6b8ce95b74910d82455ef6f8d68b09242aa05df53ca5520909f5e77890048a18e28c8ceafb86873bc243652451ca7a59a3f22d5cb30127aa8d09eccc137228d66bbd4", + "dc2f658fce2e8f2747dda92dd1ff96c7", + ), + SignVector( + "lcg-90210", + "f315c0d9b0926bea29459fbaae2099e34f1ebc04dc296fd5e50a3efbba99da726b50c6a1c807b3ab617049748697886f4788f75274d8d42c9db14bce12a6c622e3611a59e007a15299ca36365e1165523f39072d0cc23ea55577209c6ae5ec3e5b2ac052f8f21ba6d133be2136ee6b7637114d42a44699fd0d3ca1f4c2b70008d3895702102976d7098c32900e8e26642ff086d03cc6fc99c5df6e231a7dc1f54b609cf3280aeee341b36296e650ea3f27b64e93d4a02d7d7d42666b72957a0cc38de63140f62da679891978be9658f71f439a236c361cf235442032ca6083623bf2a91f584dcc97b1ee9d0b96bfde9e17773bc704e764e5edc4711b223fbfd5b36df6bd706fcb42e9c2320d6e2b36ff0f3260b09c12d0eea5a4eb147a901df12be0f76388bc196321e69662463ae452075412ad3419d20a5dc35a51d2b41902a32976e6a09411b85938854e1e4cba33ffbcb746cc5a0b04150148342a0c3b5e1b2a552fb857f98591993494f6c055b8f74c92516437c88ccd3d782d82f694d893c11445d06583c7c9e9d78acef89fc1efe33fecfc0e810885596c84dad346670bd050c2e81e4e0f01091e21a6534e78e7613aef94415a053d34e1133204fcf8833541bd00e3631939d7b1d07e3162fadfa657cc2c2fa465f5ad4ff58ae76b7afbd1391f1812bb0c7134ba8156f2a838d79249dec4375b39ada66c1ce2ddd90b73852a6c300cb66ca9005a5e2ef63b04cf051e285cbba74765fea8e23a479566eb2f1ffa4831a3bae11b3096069d004cc7dfbe84f4195e481d95b18292837972", + "6064861b192d0eadde011d3bbf9f9fd1", + "0500000001000001809864569e0efac39fe3162d85c7e3ec1388485e9fc4beee29225204decdacca1213dbfbadc0773ba42840d935a33fdfe2b1d539d050bca35e108f4ac9f499687921741ecefb1f43b5127b6cdbc079e187f1e6d3555ebf6c3e72d2ecbec39c922bcebf38aec21d15ac40463ea995c567b04b9cdc6e0381d02d9174ade540b52e5f6366c27e9cce8bf5fcc7fcf2d385e6d7c5f37ddfca194f021ba34a863f8bcb9f4c52126f49769b96aaf8afc98781bb69ba795201c526e1fc73fb7e45341bbe9b7e769919dea07c1a91e65cf8367a53b45b6322cce179751cfa119cd47b30c3de671b4fa6a339e2b271af824b31ac4bac14e136cc43a288ee140532e6c8276ed300d08758e0ece7cc0a4c75940235d93f69474f6f1bc70378ab6f84f1f84a61d6ec882bab065af68fc621158e796c5fbb42d3f325921f632403c8bdf5d014a2f6b802803f9345385e146ef08dd1ed86f0f9fe8cd0991baa08a5602ea9ee808862445683bd6664289fb98ddd6507a964b3803ff0ec2ac69d5b4f4e9deec0a5d72e000000000000004fcdb24c5d82c7b06f93be9abbd01ea6bfc9aefedbced9277defb0a831fc579612856ebac1dac4eb890b6df929e8f7eeff016eb86da654d13ee7ce4f2594aaafe13de93c2032152e2b8372c08300dc26", + "fdd96429c83a964f8f800c4f5b109e6b", + ), + SignVector( + "edge-7-norand", + "34556ccc5d4f4e26d250742aa3959258a090137f5984258d1ea8227dffe82e7ccc16311f150da1aa2a28cd2b1b1613e3b8d3be73916512e5f69ced82f7f8420164736937cdc9665c8292ceca932d249dd061fc80c9352348ce54d713ef0fdaf3fcca8d4685652039daef977b0bbc61c7e89a6ae701d506bba62f95b6e70d6e32947dc2683dc08a9132a0d46a83a103de00df13d13923688d7e8d28a7dfd2d4f42ceb57cef5b91eb58a033c83fbbd5df0188eee9271006e3d56ce5eb4d73ec01bc4734a95ad32918de27911a373f15f6830085d9ea94c3b4b2e52514dcf313ef05c77c252650a532a3a63a401eb1b164248adad22e1e76efc0679e5bec78b3853f455944c1d21113c921fd0c4631d28b360dd9a5e19b2a30fdea24ca1bf2cf55c8c6fc062d5563480ea0e7cc6dbd5594278f8caa1518bf05fb62f8475b7f4956c2424f3a88d8b611c42911b8a53250b4f905e50fe895368788e7fd572afc398a7bcd304b0459ff9e99a062e62cbebb708a86f29aac1ea991766f25584a77957e954de797ffd7199b1f2cebec5430978d6c08bc010f93010a33ee866769ff68722eca3023fb5e399564a4ae5d5bb5d7f2ed8126c943106d28a16c13554971abc288484fb8f6dd48ff2a2d8441333c99dddf064eeff694ae29ceedc3bf58fc5e1f51ce0ec962524cce0fad98c43ab2bbfbe08e2f5a7a1ddbf48c69bbeba87d7c257b4160bb5ddb2dbb952aef88623656be220ea9c3cd99fe5d29e5d4f7d7f30850f4c88b6f19560073faab5cf9d9b55462638dde94a11714a7876824baa77b02a61", + "00000000000000000000000000000000", + "050000000100000180d6d7551c3e07cbd46c1e698f193e0ba2c6a497c480975feb7cb56c8af582dde8026b2f2ae3cf9e90320d54ce99678a229071ab0b2cc97574c0c3974693052fc41378dea21f421ab95f8cdd35df0adbac1e045422f9e979e2b22236f51c8410645abca375e1899e0d75732ef8270325d2abe8739965b0368765841c1aeac3125a88dd27800d618971c56bee4fcaa557266b797cefd64fc9ea4c0007a1b366f8608fb5bd3e46480d6ccb5aad18adb8f5f90c1c38b5590680fa51078b7fad3b18e72309fd240a71b608608ae3ee61a0d9ac58e7bbeade93aef89c17a069870917c3e4f1da722a126164d1d772d4abc3232235bdf4d8f22b7a31b8c10139aaf8896c59df2ef9abb0db7c5ac76ea82013bd5fb9dd664f08cc20536262380c45c727822f7e01012e0d16a56668c9c6b173323e4161c7cd4dfaa2f01e81020b33284a956ba9ce2c37a4bb40d4010182c70652073dbedf0109987f29d786b25fd46fab10a4c99f2a9de2c04b3997c3547ac328e27c018f2f6798a2cfc9c417651de6112b000000000000004f0ef2f84f2f8493ab3cca6f2bc5939f341a2156564b34de34284e8db341a7ea1be634253f27cad988d4247de17d76797372b97f8ec3e10ef740baf1d979fd2bc0befa8bfe1fd7f3346c3a581835f8e5", + "a9569d4508e3415a7d9206c3a6cf8e25", + ), + SignVector( + "edge-8-rand-zeroblob", + "a1a3320ec6e9f0e8870df2aab4149946ddd8b46a52dc016123fb571820c80c4cd9252b2f9e6bbd997f26a5864c4646ab95461f01aaa3106e9bab6fae387bb76011b7fa9a7650ad48776693f1e412053c4db3429a02fe953b13f3cd09507972c0493794f54ef869046fad1a057cda0da005ff5fd65a4b71098bb1ceab68229cbd8186665226c3681b67db742c14fd4461bd09f440b2eb0d8803c769a980d6fe0bb984dc27fe106bc95fd03704acdaba1575b337fc0a3fe3dd7b13b30298f55002f111dd32d641fe14576cd5a944d32b392ddc9f5c62a5f4dcf3765a6ab0dfb48b290e4b4aaeb5fbdc4f8f1b7bdc4680b6e5635d74ba7e51686bd12b7dc8f438c96159852286cc08164719b44574954c219d2add8e122b9509e3028f69e094576399d3e6005ee616383feaa4e60c1f519f5510489c6a0a67b65beb0707f81f778bd15c465f3663e3db37e2cf59a443fa810df5028dc27cfac5d36ab65d10f669ad09d5767f0ea377882fe172393c63e08fc5b82e9d1ae28e164b61d69d2877eed0411cc7eee605a9b027c7a7add4dd47fe7d3b2890729aef62c3ae3f8740032fab791282f9beeb98e01f74e4cb6c13a11a355d08dcca05f4c73b33e64058fa4160b1976e0e96b4341b17c87a66046408a4edfd23c52284ff79b3ce59a070bca9f4e98b4f126ec0b5670fa3184c9c2fc6d4a5fd8b697a7581aa2b6146e188a9d46e21cf63a3466f218f07e547f734d6ce1b5d3c8dbcd239759da3caf3cca0219da85941e64c1e21c909ff6deeadccb74286159a30722a31e2ee1bebc551b884c9d0", + "0ef2f84f2f8493ab3cca6f2bc5939f34", + "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "5f7b04163f44e800282b20c5d7c395a7", + ), + ) + + private fun hex(s: String): ByteArray = + ByteArray(s.length / 2) { ((Character.digit(s[it * 2], 16) shl 4) or + Character.digit(s[it * 2 + 1], 16)).toByte() } + + @Test + fun signMatchesModel() { + for (v in vectors) { + val sig = NacSign.sign(hex(v.body576), hex(v.rand16), hex(v.blob480)) + assertContentEquals(hex(v.sig16), sig, "vector ${v.label}") + } + } +} diff --git a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt index 26a9778..99314d0 100644 --- a/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt +++ b/registration/src/test/kotlin/dev/fenn/imessage/registration/NacValidationTest.kt @@ -35,7 +35,7 @@ class NacValidationTest { val rand = hex("fa85a981ab675cf5086e3039a179553d") val sig = hex("67d46fc31402ffb7bd2aaeb9b2f85b2b") val expected = hex("02fa85a981ab675cf5086e3039a179553d67d46fc31402ffb7bd2aaeb9b2f85b2b000001e00500000001000001806c0bf5acdd4b1a845bfc27ddf00268755345d86747bb2f7aed33ef8337683b17e8ba131f2f30d283d164ce71833254883d8647c50e1c062be8c3f50d600fbbf2944fd70422b3187abe569be9ca1f2961ca8b1e1529567c4761138b33aab563e92ca156efcb5a23339e3eadba6d23be8e753ccbd26a1bc288dfe54bd250843fd5dfd8df60e1133f29bab2eaefbde9d742da34f69b38ab5d4909bbc15baa4384b71168acf3f4b518581515ad82386d4b3a9f5ee5a54721d1524325e3aeb6fef198911f05b84eff5efc924ddc96a59333e935f507ac68f53bc61d04e952f6b58c5a090963c8fb399f467be8cd8914e01e29e36fc4c4451ff30681aa36e28960c734d932220a2c92e817d1ac66f6c2f9fba06d48040ebeefef48b414bd510d8821d834ec9a105a1d50bf450f918babe971bd6dac22ca9cf22ad71ae765eaee5bb8c574e5528c727cabf3ae461642871058457068bfb620cb80765aa19a631732ee6ba4d241c6b6cf795a7c0672b388e2051f53e41dc73aba1970461173d056c441a5000000000000004f20e91cfed93217709ef434387f7b48614c77b74495233fb9aabcf7769b50733838bc8ade1164bbd176f96c1b775bacc8e4634bea4d30e1e0023727451338017250da4c1b49841d344ec155086f42bd") - assertContentEquals(expected, NacValidation.mint(cert, session, pad, rand, sig)) + assertContentEquals(expected, NacValidation.mintWithSig(cert, session, pad, rand, sig)) } @Test @@ -45,7 +45,7 @@ class NacValidationTest { val pad = stream(53, 130) val rand = stream(54, 16) val sig = stream(55, 16) - val stamp = NacValidation.mint(cert, session, pad, rand, sig) + val stamp = NacValidation.mintWithSig(cert, session, pad, rand, sig) assertEquals(517, stamp.size) assertEquals(2, stamp[0].toInt() and 0xff) assertContentEquals(rand, stamp.copyOfRange(1, 17)) @@ -60,6 +60,22 @@ class NacValidationTest { assertContentEquals(cert, stamp.copyOfRange(438, 517)) } + @Test + fun mintFullE2eMatchesModel() { + // full mint e2e: python model computed stamp517 = mint(cert79, session250, rngPad130, + // body576, rand16) in one shot (session 21; no capture-derived bytes) + val cert = hex("14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a") + val session = hex("810c90b826d1eae567d118da14bb0889bdef2fc7b2d9a2d3031d574c8074403fb9caf02cfede60445f86a497ac5878be75594a050aed67cd7b2935ff9853682cf11774f1d6cf1fe357e2627b44115bd02d42a1146213a186f34c4946b0fd997929d4fc97ae0301404fc52196dc4499e0e5896572baac5d716b675fa1c8d2e3ee61dfe9ef86daa9ce470f8bc87453c7999d10043512193986e358df81e032c0bb991996b95eb40b663fa0a4620c9da51855b6a5776ab8da095b014d62f87d9578d162d84936f1e3dd37585033a481a0850d5bafb5c2ea7582d340c84d101436d8099b831d0ef13bdc2f17cc073c61505ec5de41161a104add4bf7") + val pad = hex("ee5a56fa8f6b8da81c8e965a253a0f77fa37d1b2ab317fa708708ce7a1531e0fc6d9ea3c873d7d33b4847cf2dd88ab8652ccaa92232b66562038b72ad9d5dc8b9e5b05557f5666cf4cb627a295f63b6faa93e72d9bdb137a38eb3f3c116732467640034777964a0be482a41f4d6345b902ee5a611323c8bf50e9989649e7117a4ee8") + val body = hex("3a213df3eb01039e489b9f58e13df5be06174c04c7d10d58f423b77a1dd7a6cf929d02fd63c30b77608b1c8719c8de65de00295dbf326d328cfdae7cd5cc0a0eea4cc0c6db3b4c1e786614075161b8f3b64dcec8b7ba48ac247265648dc1d013428fe98a534b24de908c99f989e994568e5d85a5af491e86bce1b2c14595594d9ac4fd32cbd10f31a85daa83c1400310669063e5a7bf479654ac1b7bfd274276f24c08ad43af2629c039b1dff9468ea83e46ca3b9ffc7a28ec315077b559e3c44a882071bbc39c47d880041f31dc3c1316dfe67a97e049cd84d2acf66d0ad205a2d6e93633ef41c4f092669b69e01101eeba32218f4ba2991ceeb99c251a5fa7fa9713dbab11024508d08518a1338c24c639f316871d4ed6b4e4ab29dd6817b5522cd974230b650520987c95d9b526659ebbb99b7f36731f4c16e3e395d643c3aaf3819b9bbb0e6e384b51ce1147d80276a0e363777613f4e4e26bb14d4369ca024ee1db13033f1c5049766d49c793a94e481ae66fbd8cb57caa7ee1058fc8f25a9bd65d8bc1515968f249ed8116c8742613d3d867eb181714cdffa5bd99de4fb23bcdb903d73e0280a69629b914e0e2fe60cfdf5fe04dfdacaaff3c7543e48b0a8f3cfe7b231adf98c512a1f1a1c2b8d6919c69577c9dcd44a33aca2d6c4e8362f527e5f386936ab0afe066299e52d5ae0514bd4f9fd52ddc1699e0e5f34dd0bace9e396be17609c8c40ec461e9eef4861cdb364729a0337465afbb9dba4f46127b3c6de3122cb2e06417899963f2645e36e3b63ffa02040cef3d2955a07c5d") + val rand = hex("a76f0335549ca560fd571dd9f2bcfbac") + val expected = hex("02a76f0335549ca560fd571dd9f2bcfbacdeb0d8abb9ee3f6c9d5cd696955b66db000001e00500000001000001809daa70106844a654fa12bc8259e24e389238f0bf2a97cec941169a1432f8ad22bfa4909dedb5f489f94012be765a21d3e7866d85940d5410c4b06224a967f2361839cd9ab0db9291a569ffec988ee3c98ebf3f37602a64c60640a8a13eab708a953bb7ac4904c82af566d0b54ba8edabe4518e92e4c9bde6acef7ad9e42839c2f6cc25c9e63e8835df144f5c5e0cb1150d02c27395caea75dacd2d2d4b6f051e7828190e4bed710cbe6f70ccfd7786c83b0665da666c0150bd20a27bf2406515632c6f3416c1bfc2ab8ef5f68bf8af0f4bb80a2f880d9c32e32bc55c5fd5855af1258c5796be3542c422404abea395d99d886612c0490092683bcfaf3c6cd1a9356ce2097bbba51ad832877864082b0765f7a87c8e528f728919336b54a61f1b942b7a9713d936dd0f16ca3c06e04717bd1f656a1e8db1c1bb7fddde5b5e6b7eeb9e7982799cf0cb1a772946bf2482591fcf1ab046cdb3fb035930d6ba71c2645aeed76d3c2c381092624df9fa5e063d77f9970551a6c5280fe263f9ddc1de29000000000000004f14bec976bd364823b2149b59033c029b80a78edbb981c6fffec921b15f95626facbbf61c758044550a88cc3c7b2845f698e6e977f1ae6944d61ab3d357d1f3cc44d4e28d2d49d9f6620e9e54f32b7a") + val stamp = NacValidation.mint(cert, session, pad, rand, body) + assertEquals(517, stamp.size) + assertContentEquals(expected.copyOfRange(17, 33), stamp.copyOfRange(17, 33)) + assertContentEquals(expected, stamp) + } + @Test fun keyEstablishmentMatchesModel() { val pearKey = hex("aebfc2884fd1e6ffdc60273be5756ff5")