@ecopoesis/homebridge-dmx 0.1.0

package/tools/decode-frame.mjs

@@ -0,0 +1,110 @@
+// Decode a captured 576-byte DMX frame with the recovered AES-256 key, and
+// pin down the first-block IV construction.
+//
+// AES-256-CBC: blocks 1..33 decrypt from the key alone. Block 0 needs the IV:
+//   P0 = D(key, C0) XOR IV
+// We compute D(key,C0), then try nonce-derived IV constructions and pick the
+// one whose resulting P0 looks like DMX (consistent with blocks 1..33).
+//
+// Usage:
+//   node tools/decode-frame.mjs <frame.bin> [key-hex]
+//   (key defaults to the value recovered by Path C)
+
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+
+const DEFAULT_KEY =
+  '531e1b9f097be5de5785f5bf86473da34839fabb76676e95c0e4b808b42f8ac0';
+
+const [, , framePath, keyArg] = process.argv;
+if (!framePath) {
+  console.error('usage: node tools/decode-frame.mjs <frame.bin> [key-hex]');
+  process.exit(1);
+}
+const key = Buffer.from((keyArg || DEFAULT_KEY).replace(/\s/g, ''), 'hex');
+if (key.length !== 32) { console.error('key must be 32 bytes'); process.exit(1); }
+
+const frame = fs.readFileSync(framePath);
+if (frame.length !== 576) { console.error(`need 576 bytes, got ${frame.length}`); process.exit(1); }
+
+const header = frame.subarray(0, 0x20);
+const body   = frame.subarray(0x20, 0x240);          // 544 B
+const nonce  = Buffer.from(header.subarray(0x18, 0x20));
+
+console.log('header :', header.toString('hex').match(/../g).join(' '));
+console.log('  magic =', header.subarray(0, 8).toString());
+console.log('  seq   =', header[0x17], ' nonce =', nonce.toString('hex'));
+console.log('  key   =', key.toString('hex'));
+console.log();
+
+// CBC-decrypt the whole body with IV=0:
+//   out[0:16]   = D(key,C0)            = IV XOR P0
+//   out[16:544] = real plaintext P1..P33
+const d = crypto.createDecipheriv('aes-256-cbc', key, Buffer.alloc(16));
+d.setAutoPadding(false);
+const out = Buffer.concat([d.update(body), d.final()]);
+const Dt0 = out.subarray(0, 16);                     // D(key,C0)
+const known = out.subarray(16);                      // 528 bytes, real DMX
+
+let zeros = 0;
+for (const b of known) if (b === 0) zeros++;
+console.log(`plaintext blocks 1..33 (528 B real DMX, ${(zeros / known.length * 100).toFixed(1)}% zero):`);
+for (let o = 0; o < known.length; o += 32) {
+  const row = known.subarray(o, o + 32);
+  if (row.every(b => b === 0)) continue;             // skip all-zero rows
+  console.log(`  P[+0x${(o + 16).toString(16).padStart(3, '0')}] ${row.toString('hex').match(/../g).join(' ')}`);
+}
+console.log('  (all-zero rows omitted)');
+console.log();
+
+// --- recover the IV: P0 = D(key,C0) XOR IV --------------------------------
+console.log(`D(key,C0) = ${Dt0.toString('hex')}   (= IV XOR P0)`);
+console.log();
+
+const z8 = Buffer.alloc(8);
+const fieldA = Buffer.from(header.subarray(0x0a, 0x12));   // varying 8-byte field
+const blocks16 = [
+  ['nonce|0',        Buffer.concat([nonce, z8])],
+  ['0|nonce',        Buffer.concat([z8, nonce])],
+  ['nonce|nonce',    Buffer.concat([nonce, nonce])],
+  ['fieldA|nonce',   Buffer.concat([fieldA, nonce])],
+  ['nonce|fieldA',   Buffer.concat([nonce, fieldA])],
+  ['hdr[0:16]',      Buffer.from(header.subarray(0, 16))],
+  ['hdr[16:32]',     Buffer.from(header.subarray(16, 32))],
+  ['nonce|nonceR',   Buffer.concat([nonce, Buffer.from(nonce).reverse()])],
+  ['zero',           Buffer.alloc(16)],
+];
+
+function ecbEncrypt(block) {
+  const c = crypto.createCipheriv('aes-256-ecb', key, null);
+  c.setAutoPadding(false);
+  return Buffer.concat([c.update(block), c.final()]);
+}
+
+// Assuming P0 = 0 (DMX ch 1-16 off), the IV equals D(key,C0). Test which
+// construction reproduces it — directly, or as AES-256(key, block).
+console.log(`assuming P0 = 0  ->  IV should equal D(key,C0) = ${Dt0.toString('hex')}`);
+console.log();
+console.log('testing IV constructions:');
+let hit = null;
+for (const [name, blk] of blocks16) {
+  if (blk.equals(Dt0)) {
+    console.log(`  ✅ IV = ${name}   (direct)`);
+    hit = `${name} (direct)`;
+  }
+  const enc = ecbEncrypt(blk);
+  if (enc.equals(Dt0)) {
+    console.log(`  ✅ IV = AES-256-ECB(key, ${name})`);
+    hit = `AES-256-ECB(key, ${name})`;
+  }
+}
+if (!hit) {
+  console.log('  (no match — P0 may be non-zero, or IV uses other inputs)');
+  console.log();
+  console.log('Definitive next step: in HWM, set every channel to 0 (blackout),');
+  console.log('capture a frame, re-run this. Then P0 = 0 for sure and');
+  console.log('IV = D(key,C0) exactly — and these guesses will resolve it.');
+} else {
+  console.log();
+  console.log(`✅ IV CONSTRUCTION: ${hit}`);
+}

package/tools/decrypt-011c.mjs

@@ -0,0 +1,123 @@
+// Decrypt a captured 0x011c reply.
+//
+// Per FUN_1001bbca0 (Ghidra): the 240-byte ciphertext at reply[+0x2c] is
+// AES-256-CBC encrypted; IV is reply[+0x1a:+0x2a]; expected plaintext
+// length is 0x00ec (236 bytes -- last 4 of the 240B decrypt are slack/pad).
+//
+// We don't yet know the key. Try the two known candidates:
+//   1. The static SEC1 P-256 point X-coord (32 bytes)
+//   2. The XOR-deobfuscated 33-byte secret, first 32 bytes
+//
+//   node tools/decrypt-011c.mjs <pcap>
+
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+
+function ipFromEth(pkt) {
+  if (pkt.length < 14) return null;
+  let off = 12, eth = pkt.readUInt16BE(off);
+  for (let i = 0; i < 2 && eth === 0x8100; i++) { off += 4; if (off + 2 > pkt.length) return null; eth = pkt.readUInt16BE(off); }
+  return eth === 0x0800 ? pkt.subarray(off + 2) : null;
+}
+function reassemble(segs) {
+  if (!segs.length) return Buffer.alloc(0);
+  segs.sort((a, b) => (a.seq - b.seq + 0x100000000) % 0x100000000);
+  const seen = new Set(); const out = [];
+  const base = segs[0].seq;
+  for (const s of segs) {
+    const k = `${s.seq}:${s.payload.length}`; if (seen.has(k)) continue; seen.add(k);
+    const off = (s.seq - base + 0x100000000) % 0x100000000;
+    while (out.length < off + s.payload.length) out.push(0);
+    for (let i = 0; i < s.payload.length; i++) out[off + i] = s.payload[i];
+  }
+  return Buffer.from(out);
+}
+function extractReplies(pcapPath) {
+  const buf = fs.readFileSync(pcapPath);
+  const le = buf.readUInt32LE(0) === 0xa1b2c3d4;
+  const streams = new Map();
+  let off = 24;
+  while (off + 16 <= buf.length) {
+    const capLen = le ? buf.readUInt32LE(off + 8) : buf.readUInt32BE(off + 8);
+    off += 16; if (off + capLen > buf.length) break;
+    const pkt = buf.subarray(off, off + capLen); off += capLen;
+    const ip = ipFromEth(pkt); if (!ip || ip.length < 20 || ((ip[0] >> 4) & 0xf) !== 4) continue;
+    const ihl = (ip[0] & 0x0f) * 4; if (ip[9] !== 6) continue;
+    const tcp = ip.subarray(ihl);
+    const sp = tcp.readUInt16BE(0); if (sp !== 2431) continue;
+    const seq = tcp.readUInt32BE(4); const dataOff = (tcp[12] >> 4) * 4;
+    const payload = tcp.subarray(dataOff); if (!payload.length) continue;
+    const src = `${ip[12]}.${ip[13]}.${ip[14]}.${ip[15]}:${sp}`;
+    const dst = `${ip[16]}.${ip[17]}.${ip[18]}.${ip[19]}:${tcp.readUInt16BE(2)}`;
+    const k = [src, dst].sort().join('<->');
+    if (!streams.has(k)) streams.set(k, []);
+    streams.get(k).push({ seq, payload });
+  }
+  const replies = [];
+  for (const [k, segs] of streams) {
+    const r = reassemble(segs);
+    for (let i = 0; i + 24 <= r.length; i++) {
+      const m = r.subarray(i, i + 8).toString();
+      if (m !== 'Stick_3A' && m !== 'LSAG_ALL') continue;
+      if (r.readUInt16LE(i + 8) !== 0x011c) continue;
+      const len = r.readUInt32LE(i + 0x14);
+      if (len < 0x18 || len > 0x400 || i + len > r.length) continue;
+      const msg = r.subarray(i, i + len);
+      if (msg.length !== 284) continue;
+      replies.push({ pcap: pcapPath, stream: k, msg });
+    }
+  }
+  return replies;
+}
+
+// Candidate AES-256 keys.
+const KEYS = [
+  ['static SEC1 X (P-256 point)', '28081290396d063e5114526ed978b926558f6ba1c96ad2facf76fffb3ffea0fe'],
+  ['XOR-deobfuscated (first 32)', '527a5b46c56f3a5e670b4f0e338727d94737ec0fc4af0dba93a51d93965191d0'],
+  // also reversed-endian variants just in case
+  ['static SEC1 X reversed',     '28081290396d063e5114526ed978b926558f6ba1c96ad2facf76fffb3ffea0fe'.match(/../g).reverse().join('')],
+  ['XOR-deobf reversed',         '527a5b46c56f3a5e670b4f0e338727d94737ec0fc4af0dba93a51d93965191d0'.match(/../g).reverse().join('')],
+];
+
+function tryDecrypt(label, keyHex, iv, ct) {
+  try {
+    const key = Buffer.from(keyHex, 'hex');
+    if (key.length !== 32) return null;
+    const d = crypto.createDecipheriv('aes-256-cbc', key, iv);
+    d.setAutoPadding(false);
+    const pt = Buffer.concat([d.update(ct), d.final()]);
+    // score: how printable / structured?
+    let printable = 0, zero = 0;
+    for (const b of pt) {
+      if (b === 0) zero++;
+      else if (b >= 0x20 && b < 0x7f) printable++;
+    }
+    return { label, keyHex, pt, printable, zero, total: pt.length };
+  } catch (e) {
+    return { label, keyHex, err: e.message };
+  }
+}
+
+const pcaps = process.argv.slice(2);
+if (!pcaps.length) { console.error('usage: node tools/decrypt-011c.mjs <pcap> [<pcap>...]'); process.exit(1); }
+
+for (const p of pcaps) {
+  const reps = extractReplies(p);
+  console.log(`\n=== ${p}: ${reps.length} 0x011c replies ===`);
+  for (const r of reps) {
+    const tok = r.msg.readUInt32LE(0x0a);
+    const iv = r.msg.subarray(0x1a, 0x2a);
+    const ct = r.msg.subarray(0x2c, 0x2c + 240);
+    console.log(`\n  token=${tok}  IV=${iv.toString('hex')}`);
+    for (const [label, keyHex] of KEYS) {
+      const res = tryDecrypt(label, keyHex, iv, ct);
+      if (!res) continue;
+      if (res.err) { console.log(`    ${label.padEnd(28)} ERR ${res.err}`); continue; }
+      console.log(`    ${label.padEnd(28)} printable=${res.printable.toString().padStart(3)}/${res.total}  zero=${res.zero.toString().padStart(3)}  first16=${res.pt.subarray(0,16).toString('hex')}`);
+      if (res.printable > 40 || res.zero > 20) {
+        console.log(`      preview: ${res.pt.subarray(0, 64).toString('hex')}`);
+        console.log(`      ascii  : ${res.pt.subarray(0, 96).toString('binary').replace(/[^\x20-\x7e]/g, '.')}`);
+      }
+    }
+  }
+}

package/tools/decrypt-dmx.mjs

@@ -0,0 +1,130 @@
+// End-to-end decrypt test: handshake pcap + ephemeral private `d`
+//   →  KDF (P-256 double-ECDH)  →  AES-256 key
+//   →  AES-256-CBC decrypt the session's UDP DMX frames
+//   →  the 512 live DMX channel values.
+//
+// This wires the recovered KDF (derive-dmx-key.mjs) and the recovered cipher
+// into one pipeline and proves it on a real captured session.
+//
+// VERIFIED: on handshake-20260521-203416.pcap + the Path D 20:34 rsi blob it
+// derives key af90ce58… and decrypts that pcap's DMX at a 100% zero-ratio.
+//
+// Usage:
+//   node tools/decrypt-dmx.mjs <pcap> <d>
+//     <pcap>  a capture containing the TCP/2431 handshake + UDP DMX stream
+//     <d>     the ephemeral private key — 64-hex-chars, or the path to an
+//             lldb Path D rsi blob (d = blob[0x40:0x60], little-endian)
+
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { deriveDmxKey, wireToPoint, pointToWire } from './derive-dmx-key.mjs';
+
+const [, , pcapPath, dArg] = process.argv;
+if (!pcapPath || !dArg) {
+  console.error('usage: node tools/decrypt-dmx.mjs <pcap> <d-hex | rsi-blob>');
+  process.exit(1);
+}
+
+// ── load the ephemeral private d ─────────────────────────────────────────────
+let dLE;
+if (/^[0-9a-fA-F]{64}$/.test(dArg)) {
+  dLE = Buffer.from(dArg, 'hex');                 // already little-endian limbs
+} else {
+  dLE = fs.readFileSync(dArg).subarray(0x40, 0x60); // rsi blob: local_48
+}
+const dBE = Buffer.from(dLE).reverse();           // node ECDH wants big-endian
+const ecdh = crypto.createECDH('prime256v1');
+ecdh.setPrivateKey(dBE);
+const ourWire = pointToWire(ecdh.getPublicKey(null, 'uncompressed'));
+
+const pcap = fs.readFileSync(pcapPath);
+
+// ── stage 1: KDF — find the Stick pubkey Q in the handshake, derive the key ──
+// Q is the 64-byte point in the opcode-0x0F response. Collect every 64-byte
+// window that follows a "Stick_3A"+0x0F header and trial-derive: the correct Q
+// is the one whose key decrypts DMX.
+const MAGIC = Buffer.from('Stick_3A');
+
+function dmxFrames(buf) {
+  const out = [];
+  for (let o = 0; o + 576 <= buf.length; o++) {
+    if (buf.subarray(o, o + 8).equals(MAGIC) && buf[o + 8] === 0x19 && buf[o + 9] === 0x00) {
+      out.push(buf.subarray(o, o + 576));
+      o += 575;
+    }
+  }
+  return out;
+}
+
+// AES-256-CBC decrypt one 576-byte frame -> 544-byte plaintext body
+function decryptFrame(frame, key) {
+  const hdr = frame.subarray(0, 32);
+  const iv = Buffer.concat([hdr.subarray(0x0a, 0x12), hdr.subarray(0x18, 0x20)]);
+  const dec = crypto.createDecipheriv('aes-256-cbc', key, iv);
+  dec.setAutoPadding(false);
+  return Buffer.concat([dec.update(frame.subarray(32, 576)), dec.final()]);
+}
+const zeroRatio = (dmx512) => {
+  let z = 0;
+  for (const b of dmx512) if (b === 0) z++;
+  return z / dmx512.length;
+};
+
+const frames = dmxFrames(pcap);
+if (frames.length === 0) { console.error('no 576-byte DMX frames in pcap'); process.exit(1); }
+
+// candidate Q windows: 64 bytes after each "Stick_3A 0f 00" header (+0x12 req / +0x16 resp)
+const candidates = [];
+for (let o = 0; o + 0x56 <= pcap.length; o++) {
+  if (pcap.subarray(o, o + 8).equals(MAGIC) && pcap[o + 8] === 0x0f && pcap[o + 9] === 0x00) {
+    for (const off of [0x12, 0x16]) {
+      const w = pcap.subarray(o + off, o + off + 64);
+      if (w.length === 64 && !w.equals(ourWire)) candidates.push(Buffer.from(w));
+    }
+  }
+}
+
+let key = null, stickQ = null;
+for (const cand of candidates) {
+  let k;
+  try { k = deriveDmxKey(ecdh, wireToPoint(cand)); } catch { continue; }
+  if (zeroRatio(decryptFrame(frames[0], k).subarray(16, 528)) > 0.5) { key = k; stickQ = cand; break; }
+}
+if (!key) {
+  console.error('KDF: no handshake pubkey in the pcap yields a decryptable key');
+  process.exit(1);
+}
+
+console.log('Stick-DE3 — end-to-end DMX decrypt\n');
+console.log(`  pcap            : ${pcapPath}`);
+console.log(`  ephemeral d·G   : ${ourWire.subarray(0, 8).toString('hex')}… (our pubkey)`);
+console.log(`  Stick pubkey Q  : ${stickQ.subarray(0, 8).toString('hex')}…`);
+console.log(`  derived AES key : ${key.toString('hex')}`);
+console.log(`  DMX frames      : ${frames.length}\n`);
+
+// ── stage 2: decrypt the DMX stream ─────────────────────────────────────────
+let bestIdx = 0, bestRatio = 0;
+const p0set = new Set();
+for (let i = 0; i < frames.length; i++) {
+  const pt = decryptFrame(frames[i], key);
+  p0set.add(pt.subarray(0, 16).toString('hex'));
+  const r = zeroRatio(pt.subarray(16, 528));
+  if (r > bestRatio) { bestRatio = r; bestIdx = i; }
+}
+console.log(`  best frame #${bestIdx}: ${(bestRatio * 100).toFixed(1)}% of 512 DMX channels are zero`);
+console.log(`  internal header P0 distinct values across stream: ${p0set.size}`);
+
+// show the lit channels of a representative frame (first with any non-zero)
+let show = frames.findIndex((f) => zeroRatio(decryptFrame(f, key).subarray(16, 528)) < 1);
+if (show < 0) show = 0;
+const pt = decryptFrame(frames[show], key);
+const dmx = pt.subarray(16, 528);
+const lit = [];
+for (let ch = 0; ch < 512; ch++) if (dmx[ch] !== 0) lit.push(`ch${ch + 1}=${dmx[ch]}`);
+console.log(`\n  frame #${show} — P0=${pt.subarray(0, 16).toString('hex')}`);
+console.log(`  lit DMX channels (${lit.length}): ${lit.slice(0, 40).join(' ')}${lit.length > 40 ? ' …' : ''}`);
+
+const ok = bestRatio > 0.9;
+console.log(`\n${ok ? '✅ KDF + cipher VERIFIED — real DMX recovered end-to-end'
+                    : '❌ decryption did not yield plausible DMX'}`);
+process.exit(ok ? 0 : 1);

package/tools/decrypt-ssl2.ts

@@ -0,0 +1,154 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+
+// AraCrypt LFSR stream cipher - ported from HakanL's C# gist
+// https://gist.github.com/HakanL/f67fb9452d086856f105d64bc13a3f46
+
+class AraCrypt {
+  private lfsrA = 0x13579BDF
+  private lfsrB = 0x2468ACE0
+  private lfsrC = 0xFDB97531
+
+  private readonly maskA = 0x80000062
+  private readonly maskB = 0x40000020
+  private readonly maskC = 0x10000002
+  private readonly rot0A = 0x7FFFFFFF
+  private readonly rot0B = 0x3FFFFFFF
+  private readonly rot0C = 0x0FFFFFFF
+  private readonly rot1A = 0x80000000
+  private readonly rot1B = 0xC0000000
+  private readonly rot1C = 0xF0000000
+
+  setKey(key: string): void {
+    // Pad to at least 12 chars by repeating individual characters
+    let seed = key
+    let idx = 0
+    while (seed.length < 12) {
+      seed += seed[idx++]
+    }
+
+    // Reset LFSRs
+    this.lfsrA = 0x13579BDF
+    this.lfsrB = 0x2468ACE0
+    this.lfsrC = 0xFDB97531
+
+    // Distribute: chars 0-3 → A, chars 4-7 → B, chars 8-11 → C
+    for (let i = 0; i < 4; i++) {
+      this.lfsrA = (((this.lfsrA << 8) >>> 0) | seed.charCodeAt(i + 0)) >>> 0
+      this.lfsrB = (((this.lfsrB << 8) >>> 0) | seed.charCodeAt(i + 4)) >>> 0
+      this.lfsrC = (((this.lfsrC << 8) >>> 0) | seed.charCodeAt(i + 8)) >>> 0
+    }
+
+    if (this.lfsrA === 0) this.lfsrA = 0x13579BDF
+    if (this.lfsrB === 0) this.lfsrB = 0x2468ACE0
+    if (this.lfsrC === 0) this.lfsrC = 0xFDB97531
+  }
+
+  transformByte(input: number): number {
+    let crypto = 0
+    let outB = (this.lfsrB & 1) >>> 0
+    let outC = (this.lfsrC & 1) >>> 0
+
+    for (let i = 0; i < 8; i++) {
+      if ((this.lfsrA & 1) !== 0) {
+        // Clock A with feedback, then clock B
+        this.lfsrA = ((((this.lfsrA ^ this.maskA) >>> 0) >>> 1) | this.rot1A) >>> 0
+        if ((this.lfsrB & 1) !== 0) {
+          this.lfsrB = ((((this.lfsrB ^ this.maskB) >>> 0) >>> 1) | this.rot1B) >>> 0
+          outB = 1
+        } else {
+          this.lfsrB = ((this.lfsrB >>> 1) & this.rot0B) >>> 0
+          outB = 0
+        }
+      } else {
+        // Clock A without feedback, then clock C
+        this.lfsrA = ((this.lfsrA >>> 1) & this.rot0A) >>> 0
+        if ((this.lfsrC & 1) !== 0) {
+          this.lfsrC = ((((this.lfsrC ^ this.maskC) >>> 0) >>> 1) | this.rot1C) >>> 0
+          outC = 1
+        } else {
+          this.lfsrC = ((this.lfsrC >>> 1) & this.rot0C) >>> 0
+          outC = 0
+        }
+      }
+      crypto = ((crypto << 1) | (outB ^ outC)) & 0xFF
+    }
+
+    input = (input ^ crypto) & 0xFF
+    if (input === 0) input = crypto
+    return input
+  }
+
+  transform(data: Buffer): Buffer {
+    const out = Buffer.alloc(data.length)
+    for (let i = 0; i < data.length; i++) {
+      out[i] = this.transformByte(data[i])
+    }
+    return out
+  }
+}
+
+const keyCandidates = [
+  'Daslight',
+  'DasLight',
+  'daslight',
+  'DasCrypt',
+  'DasCryptKey',
+  'DasCryptV4',
+  'Daslight4',
+  'DAS',
+  'Nicolaudie-Sunlite',
+  'Nicolaudie-SUNLITE',
+  'NICOLAUDIE-SUNLITE',
+  'Nico-Sunlite',
+  'NicolaudieSunlite',
+  'Nicolaudie',
+  'nicolaudie',
+  'SUNLITE',
+  'Sunlite',
+  'SunliteSuite',
+  'Sunlite Suite',
+  'Daslight-Sunlite',
+  'DaslightSunlite',
+  'Daslight Sunlite',
+]
+
+const filePath = process.argv[2] || '/Applications/EsaPro2/ScanLibrary/_imported/WAC Lighting DC-WD05 Architectural.ssl2'
+console.log(`Reading: ${filePath}`)
+const data = readFileSync(filePath)
+console.log(`File size: ${data.length} bytes`)
+console.log(`First 16 bytes: ${Array.from(data.subarray(0, 16)).map(b => b.toString(16).padStart(2, '0')).join(' ')}`)
+
+console.log(`\nTrying ${keyCandidates.length} key candidates...\n`)
+
+for (const key of keyCandidates) {
+  const crypt = new AraCrypt()
+  crypt.setKey(key)
+  const decrypted = crypt.transform(data)
+  const head = decrypted.subarray(0, 100).toString('latin1')
+
+  const isXml = head.includes('<?xml') || head.includes('<DLM') || head.includes('<DLMFILE')
+
+  if (isXml) {
+    console.log(`*** KEY FOUND: "${key}" ***`)
+    console.log(`First 300 chars:\n${decrypted.subarray(0, 300).toString('latin1')}`)
+    const outPath = filePath.replace('.ssl2', '.xml')
+    writeFileSync(outPath, decrypted)
+    console.log(`\nDecrypted XML written to: ${outPath}`)
+    process.exit(0)
+  } else {
+    const preview = Array.from(decrypted.subarray(0, 12)).map(b =>
+      b >= 32 && b < 127 ? String.fromCharCode(b) : '.'
+    ).join('')
+    console.log(`  "${key}" → ${preview}`)
+  }
+}
+
+console.log('\nNo key matched. Dumping details for top candidates:\n')
+for (const key of keyCandidates.slice(0, 6)) {
+  const crypt = new AraCrypt()
+  crypt.setKey(key)
+  const decrypted = crypt.transform(data)
+  console.log(`Key "${key}":`)
+  console.log(`  hex: ${Array.from(decrypted.subarray(0, 40)).map(b => b.toString(16).padStart(2, '0')).join(' ')}`)
+  console.log(`  asc: ${Array.from(decrypted.subarray(0, 40)).map(b => b >= 32 && b < 127 ? String.fromCharCode(b) : '.').join('')}`)
+}