@sksoftofficial/ocduet 0.2.1

package/src/e2ee.js

@@ -0,0 +1,141 @@
+// ocduet e2ee — application-layer end-to-end encryption for phone <-> daemon.
+// Identity: daemon + each phone hold long-term Ed25519 keypairs. Pairing pins
+// the daemon key on the phone via a spoken/compared word fingerprint.
+// Session: per-connection ephemeral X25519 -> ECDH -> HKDF-SHA256 -> two
+// AES-256-GCM keys (one per direction), counter-bound 96-bit IVs (replay
+// rejected). Frames: {t:"sec", n, ct}.
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { dataDir } from "./paths.js";
+
+const KEYS_PATH = () => path.join(dataDir(), "keys.json");
+const HKDF_SALT = Buffer.from("ocduet-e2ee-v1");
+export const PD_TAG = Buffer.from("P2D\x00"); // phone -> daemon direction tag
+export const DP_TAG = Buffer.from("D2P\x00"); // daemon -> phone direction tag
+
+// 256 short common words — fingerprint byte -> word
+const WORDS = ("acid acorn actor aged agile album alert alley almond amber anchor angle ankle apple april arc arch arena armor arrow ash ashen atlas atom aunt awake axis bacon badge bagel baker balloon bamboo banjo barge basil batch beach beacon beam bean bear beech beetle bell belt berry birch bison blade blank blast blaze bloom blossom blue bluff blush boat bobcat bonfire bonsai book booth borrow bottle boulder bounce bowl brave bread breeze brick bridge bright broom brush bubble bucket buffalo bugle bulb bundle bunny burrow cabin cactus camel candle canoe canvas canyon cargo carrot castle cattle cave cedar celery cellar chalk charm cheddar cherry chess chili chimney chipmunk circle citrus clay clerk cliff cloak clock cloud clover cobalt cobra cocoa comet compass concert coral cotton cougar course coyote crab crane crate creek crest cricket crimson cross crown cube cumin curve cyclone dahlia daisy dance dawn deck deer delta denim desert diamond dice diner dingo ditch dock dolphin domain donut dragon drift drum dune eagle earth easel echo eclipse edge eel elbow elder elk elm ember emerald engine evening exact fable falcon flannel feather fedora fennel fern ferry fiber fiddle fig filter finch fire fish fjord flag flamingo flask flint float flour flute foam fog forest fossil fox frame freckle fresh frog frost fudge funnel gadget galaxy garden garlic gauge gecko gem ghost giant ginger glacier glider globe glow gnome goat gold goose gorge granite grape gravel green grotto guitar gulf gully gumbo gutter gymnast hamster harbor harvest hatch hawk hazel heather hedge helmet heron hickory hollow").split(/\s+/);
+
+export function wordsFor(buf) {
+  const h = crypto.createHash("sha256").update(buf).digest();
+  return [0, 1, 2, 3, 4, 5].map((i) => WORDS[h[i]]);
+}
+
+// ---------- key store ----------
+let store = null;
+
+export function loadKeys() {
+  if (store) return store;
+  try {
+    const raw = JSON.parse(fs.readFileSync(KEYS_PATH(), "utf8"));
+    if (raw?.identity?.priv && raw?.identity?.pub) {
+      store = {
+        priv: crypto.createPrivateKey({ key: Buffer.from(raw.identity.priv, "base64"), format: "der", type: "pkcs8" }),
+        pub: Buffer.from(raw.identity.pub, "base64"),
+        phones: new Map((raw.phones || []).map((p) => [p.id, p])),
+      };
+      return store;
+    }
+  } catch {}
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+  const pub = publicKey.export({ format: "der", type: "spki" }).slice(-32); // raw 32-byte ed25519 pub
+  const priv = privateKey.export({ format: "der", type: "pkcs8" });
+  store = { priv: crypto.createPrivateKey({ key: priv, format: "der", type: "pkcs8" }), pub, phones: new Map() };
+  saveKeys();
+  return store;
+}
+
+export function saveKeys() {
+  if (!store) return;
+  fs.mkdirSync(dataDir(), { recursive: true });
+  const tmp = KEYS_PATH() + `.${process.pid}.tmp`;
+  const priv = store.priv.export({ format: "der", type: "pkcs8" });
+  fs.writeFileSync(tmp, JSON.stringify({
+    identity: { pub: store.pub.toString("base64"), priv: priv.toString("base64") },
+    phones: [...store.phones.values()],
+  }));
+  fs.chmodSync(tmp, 0o600);
+  fs.renameSync(tmp, KEYS_PATH());
+}
+
+export function daemonPub() { return loadKeys().pub; }
+export function daemonWords() { return wordsFor(loadKeys().pub); }
+export function signDaemon(msgStr) {
+  return crypto.sign(null, Buffer.from(msgStr, "utf8"), loadKeys().priv).toString("base64");
+}
+function pubFromRaw(rawBuf, crv) {
+  const b64url = Buffer.from(rawBuf).toString("base64url");
+  return crypto.createPublicKey({ key: { kty: "OKP", crv, x: b64url }, format: "jwk" });
+}
+
+export function verifySig(pubBuf, msgStr, sigB64) {
+  try {
+    return crypto.verify(null, Buffer.from(msgStr, "utf8"), pubFromRaw(pubBuf, "Ed25519"), Buffer.from(sigB64, "base64"));
+  } catch {
+    return false;
+  }
+}
+
+export function addPhone({ id, pub }) {
+  const k = loadKeys();
+  k.phones.set(id, { id, pub, addedAt: Date.now() });
+  saveKeys();
+}
+export function phoneByPub(pubBuf) {
+  const k = loadKeys();
+  for (const p of k.phones.values()) if (Buffer.compare(Buffer.from(p.pub, "base64"), pubBuf) === 0) return p;
+  return null;
+}
+
+// ---------- session crypto ----------
+export function ephX25519() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
+  const pub = publicKey.export({ format: "der", type: "spki" }).slice(-32);
+  return { pub, priv: privateKey };
+}
+
+export function ecdh(privKeyObj, remotePubBuf) {
+  return crypto.diffieHellman({
+    privateKey: privKeyObj,
+    publicKey: pubFromRaw(remotePubBuf, "X25519"),
+  });
+}
+
+export function hsInfo(phonePubB64, phoneEphB64, daemonEphB64) {
+  return `ocduet-e2ee-v1|${phonePubB64}|${phoneEphB64}|${daemonEphB64}`;
+}
+
+export function deriveKeys(shared, infoStr) {
+  const okm = Buffer.from(crypto.hkdfSync("sha256", shared, HKDF_SALT, Buffer.from(infoStr, "utf8"), 64));
+  return { pd: okm.subarray(0, 32), dp: okm.subarray(32, 64) }; // pd = phone->daemon, dp = daemon->phone
+}
+
+function ivFor(tag, counter) {
+  const iv = Buffer.alloc(12);
+  tag.copy(iv, 0);
+  iv.writeBigUInt64BE(BigInt(counter), 4);
+  return iv;
+}
+
+export function frameEncrypt(keyBuf, tag, counter, obj) {
+  const iv = ivFor(tag, counter);
+  const cipher = crypto.createCipheriv("aes-256-gcm", keyBuf, iv, { authTagLength: 16 });
+  const ct = Buffer.concat([cipher.update(JSON.stringify(obj), "utf8"), cipher.final(), cipher.getAuthTag()]);
+  return ct.toString("base64");
+}
+
+export function frameDecrypt(keyBuf, tag, counter, ctB64) {
+  const buf = Buffer.from(ctB64, "base64");
+  if (buf.length < 16) throw new Error("short frame");
+  const iv = ivFor(tag, counter);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", keyBuf, iv, { authTagLength: 16 });
+  decipher.setAuthTag(buf.subarray(buf.length - 16));
+  const pt = Buffer.concat([decipher.update(buf.subarray(0, buf.length - 16)), decipher.final()]);
+  return JSON.parse(pt.toString("utf8"));
+}
+
+// handshake canonical strings — keep in sync with the phone
+export const hs1Msg = (phonePubB64, ephB64, token, ts) => `ocduet-hs1|${phonePubB64}|${ephB64}|${token}|${ts}`;
+export const hs2Msg = (phonePubB64, phoneEphB64, daemonEphB64) => `ocduet-hs2|${phonePubB64}|${phoneEphB64}|${daemonEphB64}`;
+export const pairMsg = (phoneId, phonePubB64, token) => `ocduet-pair|${phoneId}|${phonePubB64}|${token}`;

package/src/paths.js

@@ -0,0 +1,137 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import crypto from "node:crypto";
+
+export function opencodeConfigDir() {
+  const override = process.env.OPENCODE_CONFIG_DIR;
+  if (override) return override;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && path.isAbsolute(xdg) ? xdg : path.join(os.homedir(), ".config");
+  return path.join(base, "opencode");
+}
+
+export function pluginDir() {
+  return path.join(opencodeConfigDir(), "plugin");
+}
+
+export function dataDir() {
+  const override = process.env.OCDUET_DATA_DIR;
+  if (override && path.isAbsolute(override)) return override;
+  // opencode profiles can override XDG_DATA_HOME independently of the shell
+  // that installed the bridge. All profiles must use the same installation.
+  try {
+    const installed = JSON.parse(fs.readFileSync(installationPath(), "utf8"));
+    if (typeof installed.dataDir === "string" && path.isAbsolute(installed.dataDir)) return installed.dataDir;
+  } catch {}
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg && path.isAbsolute(xdg) ? xdg : path.join(os.homedir(), ".local", "share");
+  return path.join(base, "ocduet");
+}
+
+export function installationPath() {
+  return path.join(pluginDir(), "ocduet-installation.json");
+}
+
+export function tokenPath() {
+  return path.join(dataDir(), "token");
+}
+
+export function daemonStatePath() {
+  return path.join(dataDir(), "state.json");
+}
+
+export function daemonPidPath() {
+  return path.join(dataDir(), "daemon.pid");
+}
+
+export function daemonLogPath() {
+  return path.join(dataDir(), "daemon.log");
+}
+
+export function daemonWebDir() {
+  return path.join(dataDir(), "web");
+}
+
+// pointer file written by install: {"daemonPath": "/abs/path/to/src/daemon.js"}
+export function daemonPointerPath() {
+  return path.join(dataDir(), "daemon.json");
+}
+
+export function readDaemonPort() {
+  try {
+    const s = JSON.parse(fs.readFileSync(daemonStatePath(), "utf8"));
+    if (s && typeof s.port === "number") return s.port;
+  } catch {}
+  return null;
+}
+
+// loopback plain-http port for CLI/stub health checks — the main port is https
+// since the dual-server change, so plain fetches against it always fail
+export function readDaemonControlPort() {
+  try {
+    const s = JSON.parse(fs.readFileSync(daemonStatePath(), "utf8"));
+    if (s && typeof s.localPort === "number" && s.localPort > 0) return s.localPort;
+    if (s && typeof s.port === "number") return s.port;
+  } catch {}
+  return null;
+}
+
+export function statePath(directory) {
+  return path.join(dataDir(), `state-${slug(directory)}.json`);
+}
+
+export function slug(directory) {
+  const base = path.basename(String(directory || "").replace(/\/+$/, "")) || "project";
+  const safe = base.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "project";
+  const hash = crypto.createHash("sha256").update(String(directory || "")).digest("hex").slice(0, 8);
+  return `${safe}-${hash}`;
+}
+
+export function readToken() {
+  try {
+    const t = fs.readFileSync(tokenPath(), "utf8").trim();
+    return t || null;
+  } catch {
+    return null;
+  }
+}
+
+export function generateToken() {
+  const t = crypto.randomBytes(32).toString("base64url");
+  fs.mkdirSync(dataDir(), { recursive: true });
+  fs.writeFileSync(tokenPath(), t + "\n", { mode: 0o600 });
+  try {
+    fs.chmodSync(tokenPath(), 0o600);
+  } catch {}
+  return t;
+}
+
+export function ensureToken() {
+  return readToken() ?? generateToken();
+}
+
+const PRIVATE = [
+  { re: /^192\.168\./, rank: 0 },
+  { re: /^10\./, rank: 1 },
+  { re: /^172\.(1[6-9]|2\d|3[01])\./, rank: 2 },
+];
+
+const BAD_NIC = /^(lo|virbr|docker|veth|br-|zt|tailscale|tun|tap|utun|vmnet|wg|ppp|ipoib|wwan|rmnet)/i;
+
+export function lanIp() {
+  const ifaces = os.networkInterfaces();
+  const candidates = [];
+  for (const [name, addrs] of Object.entries(ifaces)) {
+    if (BAD_NIC.test(name)) continue;
+    for (const addr of addrs || []) {
+      if (addr.family !== "IPv4" || addr.internal) continue;
+      const priv = PRIVATE.find((p) => p.re.test(addr.address));
+      if (!priv) continue;
+      candidates.push({ address: addr.address, rank: priv.rank, name });
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => a.rank - b.rank);
+  return candidates[0].address;
+}