@ecopoesis/homebridge-dmx 0.1.0

package/tools/stick-status.mjs

@@ -0,0 +1,57 @@
+// Stick-DE3 status reader — objectively check if the device is in REMOTE/LIVE
+// mode vs standalone. Per the STICK Remote Protocol spec, once connected to
+// TCP/2431 the Stick sends a status packet every 5s. Key fields:
+//   offset 47 = Remote Clients Count
+//   offset 48 = Live Mode Is Activated  (1 = live/remote, 0 = standalone)
+// (Documented status layout starts: ID[8], OpCode, Ver, SceneNr[2],
+//  SceneName[12], ZoneNr, ZoneName[12], Dimmer[2], R,G,B, Speed[2],
+//  3x icon flags, RemoteClients, LiveMode, Screen, Led, ZoneCount,
+//  SceneState, ImgDisplayed, ImgFullscreen.)
+//
+// NOTE: on fw2.x/3.x TCP requires auth. If "Security for Cloud Access" is
+// still enabled this may only get the LSAG/auth-challenge reply, not a clean
+// status packet — which itself is the finding (device never enters remote
+// mode for us). Raw hex is always dumped so we can see exactly what comes.
+//
+// Usage: node tools/stick-status.mjs            (watches for ~30s)
+//        STICK_IP=192.168.96.2 node tools/stick-status.mjs
+
+import net from 'node:net';
+
+const STICK_IP   = process.env.STICK_IP   || '192.168.96.2';
+const STICK_PORT = Number(process.env.STICK_TCP_PORT || 2431);
+const WATCH_MS   = Number(process.env.WATCH_MS || 30000);
+const GREET = Buffer.from('4c5341475f414c4c000015000000', 'hex'); // observed LSAG_ALL client greeting
+
+const ts = () => new Date().toISOString();
+const sock = net.connect({ host: STICK_IP, port: STICK_PORT });
+sock.setNoDelay(true);
+
+sock.on('connect', () => {
+  console.log(`${ts()}  connected ${STICK_IP}:${STICK_PORT} — sending LSAG_ALL greeting`);
+  sock.write(GREET);
+});
+
+sock.on('data', (b) => {
+  const isStatus = b.length >= 49 && b.subarray(0, 8).toString('latin1') === 'Stick_3A';
+  console.log(`\n${ts()}  <-- ${b.length}B`);
+  console.log('  hex: ' + b.subarray(0, Math.min(b.length, 64)).toString('hex').replace(/(..)/g, '$1 ').trim());
+  if (isStatus) {
+    const sceneName = b.subarray(12, 24).toString('latin1').replace(/\0.*$/, '');
+    const zoneName  = b.subarray(25, 37).toString('latin1').replace(/\0.*$/, '');
+    const remoteClients = b.length > 47 ? b[47] : '?';
+    const liveMode      = b.length > 48 ? b[48] : '?';
+    console.log(`  ID=Stick_3A OpCode=${b[8]} Ver=${b[9]}`);
+    console.log(`  sceneName=${JSON.stringify(sceneName)} zoneName=${JSON.stringify(zoneName)}`);
+    console.log(`  >>> RemoteClientsCount[off47]=${remoteClients}  LiveModeIsActivated[off48]=${liveMode} <<<`);
+    if (liveMode === 0) console.log('  ** Live mode NOT active — device is in STANDALONE (this is the suspected root cause) **');
+    if (liveMode === 1) console.log('  ** Live mode ACTIVE — device is in REMOTE mode **');
+  } else {
+    console.log('  (not a documented status packet — likely the LSAG/auth-challenge reply; fw3 TCP auth not satisfied)');
+  }
+});
+
+sock.on('error', (e) => console.log(`${ts()}  error: ${e.message}`));
+sock.on('close', () => console.log(`${ts()}  closed`));
+
+setTimeout(() => { console.log(`\n${ts()}  done (${WATCH_MS}ms)`); sock.destroy(); process.exit(0); }, WATCH_MS);

package/tools/test-aes-detector.mjs

@@ -0,0 +1,100 @@
+// Self-test for the AES-128 key-schedule detector used by Path A.
+//
+// Validates the detector in BOTH scan-aes-schedule.mjs (JS) and
+// lldb-pathA-scan.py (Python) against the FIPS-197 Appendix A.1 known
+// answer, plus an independent key-expansion generator and a negative case.
+//
+//   node tools/test-aes-detector.mjs
+
+import { execFileSync } from 'node:child_process';
+import { scheduleKey, SBOX, RCON } from './scan-aes-schedule.mjs';
+
+let pass = 0, fail = 0;
+function check(name, cond) {
+  if (cond) { pass++; console.log(`  ok   ${name}`); }
+  else      { fail++; console.log(`  FAIL ${name}`); }
+}
+
+// FIPS-197 Appendix A.1: key expansion for this 128-bit key.
+const KEY = '2b7e151628aed2a6abf7158809cf4f3c';
+// The full 176-byte forward key schedule (w[0]..w[43]) from FIPS-197 A.1.
+const FIPS_SCHEDULE =
+  '2b7e151628aed2a6abf7158809cf4f3c' + 'a0fafe1788542cb123a339392a6c7605' +
+  'f2c295f27a96b9435935807a7359f67f' + '3d80477d4716fe3e1e237e446d7a883b' +
+  'ef44a541a8525b7fb671253bdb0bad00' + 'd4d1c6f87c839d87caf2b8bc11f915bc' +
+  '6d88a37a110b3efddbf98641ca0093fd' + '4e54f70e5f5fc9f384a64fb24ea6dc4f' +
+  'ead27321b58dbad2312bf5607f8d292f' + 'ac7766f319fadc2128d12941575c006e' +
+  'd014f9a8c9ee2589e13f0cc8b6630ca6';
+
+// --- independent AES-128 key-expansion generator -------------------------
+function expandKey128(key) {
+  const out = Buffer.alloc(176);
+  key.copy(out, 0);
+  for (let i = 4; i < 44; i++) {
+    const prev = out.subarray(4 * (i - 1), 4 * i);
+    let t = [prev[0], prev[1], prev[2], prev[3]];
+    if (i % 4 === 0) {
+      t = [t[1], t[2], t[3], t[0]];               // RotWord
+      t = [SBOX[t[0]], SBOX[t[1]], SBOX[t[2]], SBOX[t[3]]]; // SubWord
+      t[0] ^= RCON[i / 4 - 1];                    // Rcon
+    }
+    for (let k = 0; k < 4; k++)
+      out[4 * i + k] = out[4 * (i - 4) + k] ^ t[k];
+  }
+  return out;
+}
+
+const keyBuf = Buffer.from(KEY, 'hex');
+const fipsBuf = Buffer.from(FIPS_SCHEDULE, 'hex');
+
+console.log('FIPS-197 length check:');
+check('176-byte schedule vector', fipsBuf.length === 176);
+
+console.log('\nindependent generator vs FIPS-197 known answer:');
+const gen = expandKey128(keyBuf);
+check('expandKey128(key) === FIPS-197 schedule', gen.equals(fipsBuf));
+
+console.log('\nJS detector (scheduleKey):');
+const k1 = scheduleKey(fipsBuf, 0);
+check('recovers key from FIPS-197 schedule @ offset 0',
+      k1 != null && k1.toString('hex') === KEY);
+
+// embedded at a non-zero offset inside a larger buffer of noise
+const wrap = Buffer.concat([Buffer.alloc(32, 0xAB), fipsBuf, Buffer.alloc(48, 0xCD)]);
+let foundOff = -1, foundKey = null;
+for (let o = 0; o + 176 <= wrap.length; o++) {
+  const kk = scheduleKey(wrap, o);
+  if (kk) { foundOff = o; foundKey = kk; }
+}
+check('finds schedule embedded at offset 32',
+      foundOff === 32 && foundKey && foundKey.toString('hex') === KEY);
+
+console.log('\nnegative case (random data must NOT match):');
+const noise = Buffer.alloc(4096);
+for (let i = 0; i < noise.length; i++) noise[i] = (i * 2654435761) & 0xff;
+let falsePos = 0;
+for (let o = 0; o + 176 <= noise.length; o++) if (scheduleKey(noise, o)) falsePos++;
+check('zero false positives on 4 KiB of pseudo-random data', falsePos === 0);
+
+console.log('\nPython detector (lldb-pathA-scan.py: aes128_schedule_check):');
+try {
+  const pyScript = `
+import importlib.util
+spec = importlib.util.spec_from_file_location("p", "tools/lldb_pathA_scan.py")
+m = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(m)
+k = m.aes128_schedule_check(bytes.fromhex("${FIPS_SCHEDULE}"))
+print(k.hex() if k else "NONE")
+bad = m.aes128_schedule_check(bytes([(i*7)&0xff for i in range(176)]))
+print("NONE" if bad is None else bad.hex())
+`;
+  const out = execFileSync('python3', ['-c', pyScript], { encoding: 'utf8' }).trim().split('\n');
+  check('Python recovers key from FIPS-197 schedule', out[0] === KEY);
+  check('Python rejects non-schedule data', out[1] === 'NONE');
+} catch (e) {
+  fail++;
+  console.log(`  FAIL python parity test: ${e.message}`);
+}
+
+console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed`);
+process.exit(fail === 0 ? 0 : 1);

package/tools/test-tcp-write.ts

@@ -0,0 +1,274 @@
+import * as net from 'net';
+import * as crypto from 'crypto';
+
+const STICK_HOST = '192.168.96.2';
+const STICK_PORT = 2431;
+const MAGIC_CLIENT = Buffer.from('LSAG_ALL');
+const MAGIC_STICK = Buffer.from('Stick_3A');
+
+function hexDump(label: string, buf: Buffer, maxLen = 128) {
+  console.log(`\n--- ${label} (${buf.length} bytes) ---`);
+  const len = Math.min(buf.length, maxLen);
+  for (let i = 0; i < len; i += 16) {
+    const hex = [];
+    const ascii = [];
+    for (let j = 0; j < 16; j++) {
+      if (i + j < len) {
+        hex.push(buf[i + j].toString(16).padStart(2, '0'));
+        const c = buf[i + j];
+        ascii.push(c >= 32 && c < 127 ? String.fromCharCode(c) : '.');
+      } else {
+        hex.push('  ');
+      }
+    }
+    console.log(`  ${i.toString(16).padStart(4, '0')}  ${hex.join(' ')}  ${ascii.join('')}`);
+  }
+  if (buf.length > maxLen) console.log(`  ... (${buf.length - maxLen} more bytes)`);
+}
+
+class StickConnection {
+  private sock: net.Socket;
+  private recvBuf = Buffer.alloc(0);
+  private resolveRead: ((buf: Buffer) => void) | null = null;
+  private readTarget = 0;
+
+  constructor() {
+    this.sock = new net.Socket();
+    this.sock.on('data', (data) => {
+      this.recvBuf = Buffer.concat([this.recvBuf, data]);
+      this.checkRead();
+    });
+  }
+
+  private checkRead() {
+    if (this.resolveRead && this.recvBuf.length >= this.readTarget) {
+      const result = this.recvBuf.subarray(0, this.readTarget);
+      this.recvBuf = this.recvBuf.subarray(this.readTarget);
+      const resolve = this.resolveRead;
+      this.resolveRead = null;
+      resolve(result);
+    }
+  }
+
+  read(n: number, timeout = 5000): Promise<Buffer> {
+    if (this.recvBuf.length >= n) {
+      const result = this.recvBuf.subarray(0, n);
+      this.recvBuf = this.recvBuf.subarray(n);
+      return Promise.resolve(result);
+    }
+    return new Promise((resolve, reject) => {
+      this.readTarget = n;
+      this.resolveRead = resolve;
+      const timer = setTimeout(() => {
+        this.resolveRead = null;
+        reject(new Error(`timeout reading ${n} bytes, have ${this.recvBuf.length}`));
+      }, timeout);
+      const origResolve = this.resolveRead;
+      this.resolveRead = (buf) => {
+        clearTimeout(timer);
+        resolve(buf);
+      };
+    });
+  }
+
+  async readMessage(): Promise<{ opcode: number; seq: number; payload: Buffer }> {
+    const header = await this.read(10);
+    const magic = header.subarray(0, 8).toString();
+    const opcode = header.readUInt8(8) | (header.readUInt8(9) << 8);
+
+    // Different opcodes have different response sizes
+    // Read the seq+reserved block (6 bytes minimum)
+    if (opcode === 0xc9) {
+      // Device info: 48 bytes after header
+      const data = await this.read(48);
+      return { opcode, seq: 0, payload: data };
+    } else if (opcode === 0x25) {
+      // Capability mask - variable, read remaining
+      const data = await this.read(30);
+      return { opcode, seq: 0, payload: data };
+    } else if (opcode === 0x47) {
+      // G hello response: 8 bytes ack + 36 bytes (4 + 32 pubkey)
+      const data = await this.read(44);
+      return { opcode, seq: data.readUInt16LE(0), payload: data.subarray(8) };
+    } else if (opcode === 0x48) {
+      // H key exchange ack: 8 bytes + 4 bytes
+      const data = await this.read(12);
+      return { opcode, seq: data.readUInt16LE(0), payload: data.subarray(8) };
+    } else if (opcode === 0x011c) {
+      // Session setup: 12 bytes ack then variable
+      const ack = await this.read(12);
+      const payloadLen = ack.readUInt16LE(8);
+      if (payloadLen > 0) {
+        const data = await this.read(payloadLen);
+        return { opcode, seq: ack.readUInt16LE(0), payload: data };
+      }
+      return { opcode, seq: ack.readUInt16LE(0), payload: Buffer.alloc(0) };
+    } else if (opcode === 0x70) {
+      // DMX response: 12 bytes ack + 512 bytes state
+      const ack = await this.read(12);
+      const state = await this.read(512);
+      return { opcode, seq: ack.readUInt16LE(0), payload: state };
+    } else {
+      // Unknown - try reading 12 bytes
+      const data = await this.read(12).catch(() => Buffer.alloc(0));
+      return { opcode, seq: 0, payload: data };
+    }
+  }
+
+  send(buf: Buffer) {
+    this.sock.write(buf);
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.sock.connect(STICK_PORT, STICK_HOST, resolve);
+      this.sock.on('error', reject);
+    });
+  }
+
+  close() {
+    this.sock.destroy();
+  }
+
+  get buffered() { return this.recvBuf.length; }
+}
+
+// Build a protocol packet: magic(8) + opcode(2) + seq(2) + reserved(6) + payload
+function buildPacket(magic: Buffer, opcode: number, seq: number, payload: Buffer): Buffer {
+  const header = Buffer.alloc(18);
+  magic.copy(header, 0);
+  header.writeUInt8(opcode & 0xff, 8);
+  header.writeUInt8((opcode >> 8) & 0xff, 9);
+  header.writeUInt16LE(seq, 10);
+  // bytes 12-17 are zero (reserved)
+  return Buffer.concat([header, payload]);
+}
+
+async function main() {
+  const conn = new StickConnection();
+  await conn.connect();
+  console.log('Connected to Stick');
+
+  // Step 1: ECDH Hello (opcode G = 0x47)
+  const helloPacket = buildPacket(MAGIC_CLIENT, 0x47, 6, Buffer.alloc(0));
+  hexDump('SEND hello (G)', helloPacket);
+  conn.send(helloPacket);
+
+  let helloResp = await conn.readMessage();
+  console.log(`RECV opcode=0x${helloResp.opcode.toString(16)} seq=${helloResp.seq}`);
+  hexDump('hello payload', helloResp.payload);
+
+  // Drain unsolicited 0x25 capability messages until we get the 0x47 hello
+  while (helloResp.opcode === 0x25) {
+    console.log('Got capability mask, reading next message...');
+    helloResp = await conn.readMessage();
+    console.log(`RECV opcode=0x${helloResp.opcode.toString(16)}`);
+    hexDump('payload', helloResp.payload);
+  }
+
+  if (helloResp.opcode !== 0x47) {
+    console.error(`Expected hello (0x47), got 0x${helloResp.opcode.toString(16)}`);
+    conn.close();
+    return;
+  }
+
+  // Extract Stick's ECDH public key (32 bytes, offset 4 in payload)
+  const stickPubKey = helloResp.payload.subarray(4, 36);
+  console.log(`Stick pubkey: ${stickPubKey.toString('hex')}`);
+
+  // Step 2: Generate X25519 key pair
+  const clientKeys = crypto.generateKeyPairSync('x25519');
+  const clientPubRaw = clientKeys.publicKey.export({ type: 'spki', format: 'der' });
+  const clientPubKey = clientPubRaw.subarray(clientPubRaw.length - 32);
+  console.log(`Client pubkey: ${clientPubKey.toString('hex')}`);
+
+  // Derive shared secret
+  const stickPubKeyObj = crypto.createPublicKey({
+    key: Buffer.concat([
+      Buffer.from('302a300506032b656e032100', 'hex'),
+      stickPubKey,
+    ]),
+    format: 'der',
+    type: 'spki',
+  });
+  const sharedSecret = crypto.diffieHellman({
+    privateKey: clientKeys.privateKey,
+    publicKey: stickPubKeyObj,
+  });
+  console.log(`Shared secret: ${sharedSecret.toString('hex')}`);
+
+  // Step 3: Key exchange (opcode H = 0x48)
+  const softwareName = Buffer.alloc(32);
+  Buffer.from('software').copy(softwareName);
+  const keyExPayload = Buffer.concat([softwareName, stickPubKey, clientPubKey]);
+  const keyExPacket = buildPacket(MAGIC_CLIENT, 0x48, 7, keyExPayload);
+  hexDump('SEND key exchange (H)', keyExPacket);
+  conn.send(keyExPacket);
+
+  const keyExResp = await conn.readMessage();
+  console.log(`RECV opcode=0x${keyExResp.opcode.toString(16)}`);
+  hexDump('key exchange response', keyExResp.payload);
+
+  // Drain any unsolicited messages
+  if (conn.buffered > 0) {
+    console.log(`${conn.buffered} bytes buffered, reading...`);
+    const extra = await conn.readMessage().catch(() => null);
+    if (extra) console.log(`Extra message: opcode=0x${extra.opcode.toString(16)}`);
+  }
+
+  // Step 4: Init (opcode F = 0x46)
+  const initPacket = Buffer.from([...MAGIC_STICK, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00]);
+  hexDump('SEND init (F)', initPacket);
+  conn.send(initPacket);
+
+  // Step 5: Device query
+  const queryPacket = Buffer.from([...MAGIC_STICK, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00]);
+  hexDump('SEND device query', queryPacket);
+  conn.send(queryPacket);
+
+  const devResp = await conn.readMessage();
+  console.log(`RECV opcode=0x${devResp.opcode.toString(16)} (device info)`);
+  hexDump('device info', devResp.payload, 48);
+
+  // Step 6: Session setup (opcode 0x011C)
+  const sessionPayload = Buffer.from([0x15, 0x00, 0x16, 0x00]);
+  const sessionPacket = buildPacket(MAGIC_STICK, 0x011c, 8, sessionPayload);
+  hexDump('SEND session setup', sessionPacket);
+  conn.send(sessionPacket);
+
+  const sessResp = await conn.readMessage();
+  console.log(`RECV opcode=0x${sessResp.opcode.toString(16)} (session)`);
+
+  // Drain any extra messages
+  await new Promise(r => setTimeout(r, 500));
+  while (conn.buffered > 0) {
+    const msg = await conn.readMessage().catch(() => null);
+    if (msg) console.log(`Extra: opcode=0x${msg.opcode.toString(16)}, payload=${msg.payload.length} bytes`);
+    else break;
+  }
+
+  // Step 7: Make fixture 2 RED
+  // DMX addr 6 = intensity 255, addr 9 = saturation 255, addr 10 = hue 0 (red)
+  console.log('\n=== Making fixture 2 RED ===');
+  const writes: [number, number, string][] = [
+    [6, 255, 'intensity'],
+    [9, 255, 'saturation'],
+    [10, 0,  'hue (red=0)'],
+  ];
+
+  let dmxSeq = 0x15;
+  for (const [channel, value, label] of writes) {
+    const payload = Buffer.from([value, 0x00, 0x00, 0x00, channel]);
+    const packet = buildPacket(MAGIC_STICK, 0x70, dmxSeq++, payload);
+    console.log(`  ch${channel} = ${value} (${label})`);
+    conn.send(packet);
+    await new Promise(r => setTimeout(r, 100));
+  }
+  console.log('All writes sent. Waiting 2s for Stick to process...');
+  await new Promise(r => setTimeout(r, 2000));
+
+  console.log('\nDone.');
+  conn.close();
+}
+
+main().catch(console.error);