web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/implements/threaddb/common/key.js

@@ -0,0 +1,245 @@
+'use strict';
+
+var tweetnacl = require('tweetnacl');
+var base32 = require('../../../node_modules/multiformats/dist/src/bases/base32.js');
+var keyManager = require('../../../common/dc-key/keyManager.js');
+var index = require('../../../node_modules/jscrypto/es6/index.js');
+
+const {
+  Word32Array,
+  AES,
+  pad,
+  mode,
+  Base64
+} = index;
+// Constants
+const NonceBytes = 12;
+const TagBytes = 16;
+const KeyBytes = 32;
+class InvalidKeyError extends Error {
+  constructor() {
+    super('invalid key');
+    this.name = 'InvalidKeyError';
+  }
+}
+/**
+ * Key is a wrapper for a symmetric key
+ */
+class SymmetricKey {
+  constructor(rawBytes) {
+    Object.defineProperty(this, "_raw", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._raw = rawBytes;
+  }
+  /**
+   * Generate a new random key
+   */
+  static newRandom() {
+    const rawBytes = tweetnacl.randomBytes(KeyBytes);
+    return new SymmetricKey(rawBytes);
+  }
+  /**
+   * Creates a key without error handling (will throw if fails)
+   */
+  static new() {
+    return SymmetricKey.newRandom();
+  }
+  /**
+   * Create a key from raw bytes
+   */
+  static fromBytes(k) {
+    if (k.length !== KeyBytes) {
+      throw new InvalidKeyError();
+    }
+    return new SymmetricKey(k);
+  }
+  /**
+   * Create a key from a base32-encoded string
+   */
+  static fromString(k) {
+    try {
+      const bytes = base32.base32.decode(k);
+      return SymmetricKey.fromBytes(bytes);
+    } catch (err) {
+      throw new Error(`Failed to decode key: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async toSymKey() {
+    const symKey = keyManager.symKeyFromBytes(this._raw);
+    return symKey;
+  }
+  static fromSymKey(symKey) {
+    return new SymmetricKey(symKey.raw);
+  }
+  /**
+   * Get raw key bytes
+   */
+  get raw() {
+    return this._raw;
+  }
+  /**
+   * Return raw key bytes
+   */
+  bytes() {
+    return this._raw;
+  }
+  /**
+   * Convert key to binary format
+   */
+  marshalBinary() {
+    return this._raw;
+  }
+  /**
+   * Return base32-encoded string representation
+   */
+  toString() {
+    try {
+      return base32.base32.encode(this.raw);
+    } catch (err) {
+      throw new Error(`Failed to encode key: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  // /**
+  //  * Encrypt performs AES-256 GCM encryption on plaintext
+  //  */
+  // encrypt(plaintext: Uint8Array): Uint8Array {
+  //   // Generate a random nonce
+  //   const nonce = randomBytes(secretbox.nonceLength)  ;
+  //   const box = secretbox(plaintext, nonce, this._raw)  
+  //   const encrypted = new Uint8Array(nonce.length + box.length)  
+  //   encrypted.set(nonce)  
+  //   encrypted.set(box, nonce.length)  
+  //   return encrypted  
+  // }
+  async encrypt(plaintext, exNonce) {
+    let nonce = tweetnacl.randomBytes(NonceBytes);
+    if (exNonce && exNonce.length === NonceBytes) {
+      nonce = exNonce;
+    }
+    // 生成随机初始化向量 (96 bits)  
+    const iv = crypto.getRandomValues(nonce);
+    // 加密配置  
+    const algorithm = {
+      name: "AES-GCM",
+      iv: iv,
+      tagLength: 128 // 认证标签长度 (bits)  
+    };
+    const symKey = await this.toSymKey();
+    // 执行加密  
+    const ciphertext = await crypto.subtle.encrypt(algorithm, symKey.key, plaintext);
+    // 提取认证标签（最后16字节）  
+    //const tag = ciphertext.slice(ciphertext.byteLength - 16);  
+    // 分离密文主体（去除标签）  
+    // const ciphertextBody = ciphertext.slice(0, ciphertext.byteLength - 16);  
+    const result = new Uint8Array(nonce.length + ciphertext.byteLength);
+    result.set(nonce, 0);
+    result.set(new Uint8Array(ciphertext), nonce.length);
+    return result;
+  }
+  /**
+   * Decrypt uses key to perform AES-256 GCM decryption on ciphertext
+   */
+  async decrypt(encryptBuffer) {
+    if (encryptBuffer.length <= 28) {
+      return encryptBuffer;
+    }
+    const nonce = encryptBuffer.subarray(0, NonceBytes);
+    const iv = new Word32Array(nonce);
+    const tag = encryptBuffer.subarray(encryptBuffer.length - TagBytes, encryptBuffer.length);
+    const kdfSalt = new Word32Array(tag);
+    const encryptContent = encryptBuffer.subarray(NonceBytes, encryptBuffer.length - TagBytes);
+    const cipherText = new Word32Array(encryptContent);
+    const key = new Word32Array(this._raw);
+    const decrypted = AES.decrypt(cipherText.toString(Base64), key, {
+      iv: iv,
+      padding: pad.NoPadding,
+      mode: mode.GCM,
+      kdfSalt: kdfSalt
+    });
+    return decrypted.toUint8Array();
+  }
+}
+Object.defineProperty(SymmetricKey, "keyBytes", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: 32
+});
+class Key {
+  constructor(sk, rk) {
+    Object.defineProperty(this, "sk", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "rk", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.sk = sk;
+    if (rk) {
+      this.rk = rk;
+    }
+  }
+  static new(sk, rk) {
+    if (!sk) {
+      throw new Error('service-key must not be null');
+    }
+    return new Key(sk, rk);
+  }
+  static newRandom() {
+    return new Key(SymmetricKey.new(), SymmetricKey.new());
+  }
+  static newRandomService() {
+    return new Key(SymmetricKey.new());
+  }
+  static fromBytes(b) {
+    if (b.length !== SymmetricKey.keyBytes && b.length !== SymmetricKey.keyBytes * 2) {
+      throw new Error('invalid key');
+    }
+    const sk = SymmetricKey.fromBytes(b.slice(0, SymmetricKey.keyBytes));
+    if (b.length === SymmetricKey.keyBytes * 2) {
+      const rk = SymmetricKey.fromBytes(b.slice(SymmetricKey.keyBytes));
+      return new Key(sk, rk);
+    }
+    return new Key(sk);
+  }
+  static fromString(s) {
+    const decoded = base32.base32.decode(s);
+    return Key.fromBytes(decoded);
+  }
+  service() {
+    return this.sk;
+  }
+  read() {
+    return this.rk;
+  }
+  defined() {
+    return this.sk !== null;
+  }
+  canRead() {
+    return this.rk !== null;
+  }
+  toBytes() {
+    if (this.rk && this.sk) {
+      return new Uint8Array([...this.sk.bytes(), ...this.rk.bytes()]);
+    } else if (this.sk) {
+      return this.sk.bytes();
+    } else {
+      return new Uint8Array(0);
+    }
+  }
+  toString() {
+    return base32.base32.encode(this.toBytes());
+  }
+}
+
+exports.Key = Key;
+exports.SymmetricKey = SymmetricKey;

package/dist/cjs/implements/threaddb/common/lineReader.js

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * 从ReadableStream逐行读取数据的工具类
+ */
+class LineReader {
+  /**
+   * 创建LineReader实例
+   * @param stream 可读数据流
+   * @param encoding 文本编码（默认为'utf-8'）
+   */
+  constructor(stream) {
+    let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf-8';
+    Object.defineProperty(this, "reader", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "textDecoder", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "buffer", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: ''
+    });
+    Object.defineProperty(this, "isEOF", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
+    this.reader = stream.getReader();
+    this.textDecoder = new TextDecoder(encoding);
+  }
+  /**
+   * 读取下一行数据
+   * @returns 返回一行数据，如果到达流末尾则返回null
+   */
+  async readLine() {
+    // 如果已经到达EOF且缓冲区为空，则返回null
+    if (this.isEOF && this.buffer.length === 0) {
+      return null;
+    }
+    // 尝试从缓冲区中找到一行
+    const newlineIndex = this.buffer.indexOf('\n');
+    if (newlineIndex !== -1) {
+      // 找到完整行，提取并更新缓冲区
+      const line = this.buffer.substring(0, newlineIndex);
+      this.buffer = this.buffer.substring(newlineIndex + 1);
+      return line;
+    }
+    // 需要读取更多数据
+    if (!this.isEOF) {
+      const {
+        value,
+        done
+      } = await this.reader.read();
+      if (done) {
+        // 流结束，返回剩余的缓冲区内容作为最后一行
+        this.isEOF = true;
+        if (this.buffer.length > 0) {
+          const lastLine = this.buffer;
+          this.buffer = '';
+          return lastLine;
+        }
+        return null;
+      }
+      // 将新数据添加到缓冲区并递归调用
+      this.buffer += this.textDecoder.decode(value, {
+        stream: true
+      });
+      return this.readLine();
+    }
+    // 已到达EOF，但缓冲区还有内容
+    if (this.buffer.length > 0) {
+      const lastLine = this.buffer;
+      this.buffer = '';
+      return lastLine;
+    }
+    return null;
+  }
+  /**
+   * 释放读取器资源
+   */
+  release() {
+    this.reader.releaseLock();
+  }
+}
+
+exports.LineReader = LineReader;

package/dist/cjs/implements/threaddb/common/logstore.js

@@ -0,0 +1,221 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var asyncMutex = require('async-mutex');
+var key = require('./key.js');
+var utils = require('../../../util/utils.js');
+var core = require('../core/core.js');
+var db = require('../core/db.js');
+
+// Package logstore provides local store for thread logs. The subpackages provide creators for different types of store implementations.
+const PermanentAddrTTL = 2 ^ 53 - 1; // 使用 bigint 精确表示 64 位整数  
+const managedSuffix = "/managed";
+// NewLogstore creates a new log store from the given books.
+function newLogstore(kb, ab, hb, md) {
+  return new Logstore(kb, ab, hb, md);
+}
+// logstore is a collection of books for storing thread logs.
+class Logstore {
+  constructor(keyBook, addrBook, headBook, metadata) {
+    Object.defineProperty(this, "keyBook", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: keyBook
+    });
+    Object.defineProperty(this, "addrBook", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: addrBook
+    });
+    Object.defineProperty(this, "headBook", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: headBook
+    });
+    Object.defineProperty(this, "metadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: metadata
+    });
+    Object.defineProperty(this, "mutex", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new asyncMutex.Mutex()
+    });
+  }
+  // Close the logstore.
+  async close() {
+    const errs = [];
+    const weakClose = async (name, c) => {
+      if (c && typeof c.close === 'function') {
+        try {
+          await c.close();
+        } catch (err) {
+          errs.push(new Error(`${name} error: ${err}`));
+        }
+      }
+    };
+    await weakClose("keybook", this.keyBook);
+    await weakClose("addressbook", this.addrBook);
+    await weakClose("headbook", this.headBook);
+    await weakClose("threadmetadata", this.metadata);
+    if (errs.length > 0) {
+      throw new Error(`failed while closing logstore; err(s): ${errs.map(e => e.message).join(', ')}`);
+    }
+  }
+  // Threads returns a list of the thread IDs in the store.
+  async threads() {
+    return this.mutex.runExclusive(async () => {
+      const set = new Set();
+      const threadsFromKeys = await this.keyBook.threadsFromKeys();
+      threadsFromKeys.forEach(t => set.add(t));
+      const threadsFromAddrs = await this.addrBook.threadsFromAddrs();
+      threadsFromAddrs.forEach(t => set.add(t));
+      return Array.from(set);
+    });
+  }
+  // AddThread adds a thread with keys.
+  async addThread(info) {
+    if (!info.key?.service()) {
+      throw new Error("a service-key is required to add a thread");
+    }
+    const sk = await this.keyBook.serviceKey(info.id);
+    const symKey = await info.key.service()?.toSymKey();
+    if (!sk) {
+      if (!symKey) {
+        throw new Error("service-key is required");
+      }
+      await this.keyBook.addServiceKey(info.id, symKey);
+    } else if (!symKey || !utils.compareByteArrays(symKey.raw, sk.raw)) {
+      throw new Error("service-key mismatch");
+    }
+    if (info.key.canRead()) {
+      const rk = await this.keyBook.readKey(info.id);
+      const readKey = await info.key.read()?.toSymKey();
+      if (!rk) {
+        if (!readKey) {
+          throw new Error("read-key is required");
+        }
+        await this.keyBook.addReadKey(info.id, readKey);
+      } else if (!readKey || !utils.compareByteArrays(readKey.raw, rk.raw)) {
+        throw new Error("read-key mismatch");
+      }
+    }
+  }
+  // GetThread returns thread info of the given id.
+  async getThread(id) {
+    const sk = await this.keyBook.serviceKey(id);
+    if (!sk) {
+      throw db.Errors.ErrThreadNotFound;
+    }
+    const rk = await this.keyBook.readKey(id);
+    const set = await this.getLogIDs(id);
+    const logs = [];
+    for (const l of set) {
+      const i = await this.getLog(id, l);
+      logs.push(i);
+    }
+    let threadKey = new key.Key(key.SymmetricKey.fromSymKey(sk));
+    if (rk) {
+      threadKey = new key.Key(key.SymmetricKey.fromSymKey(sk), key.SymmetricKey.fromSymKey(rk));
+    }
+    const threadInfo = new core.ThreadInfo(id, logs, [], threadKey);
+    return threadInfo;
+  }
+  async getLogIDs(id) {
+    const set = new Set();
+    const logsWithKeys = await this.keyBook.logsWithKeys(id);
+    logsWithKeys.forEach(l => set.add(l));
+    const logsWithAddrs = await this.addrBook.logsWithAddrs(id);
+    logsWithAddrs.forEach(l => set.add(l));
+    return set;
+  }
+  // DeleteThread deletes a thread.
+  async deleteThread(id) {
+    await this.keyBook.clearKeys(id);
+    await this.metadata.clearMetadata(id);
+    const set = await this.getLogIDs(id);
+    for (const l of set) {
+      await this.addrBook.clearAddrs(id, l);
+      await this.headBook.clearHeads(id, l);
+    }
+  }
+  // AddLog adds a log under the given thread.
+  async addLog(id, lg) {
+    if (lg.privKey) {
+      const pk = await this.keyBook.privKey(id, lg.id);
+      if (pk) {
+        throw db.Errors.ErrLogExists;
+      }
+      await this.keyBook.addPrivKey(id, lg.id, lg.privKey);
+    }
+    if (!lg.pubKey) {
+      throw new Error("public key is required");
+    }
+    await this.keyBook.addPubKey(id, lg.id, lg.pubKey);
+    await this.addrBook.addAddrs(id, lg.id, lg.addrs, PermanentAddrTTL);
+    if (lg.head) {
+      await this.headBook.setHead(id, lg.id, lg.head);
+    }
+    if (lg.managed || lg.privKey) {
+      await this.metadata.putBool(id, lg.id.toString() + managedSuffix, true);
+    }
+    return;
+  }
+  // GetLog returns info about the given thread.
+  async getLog(id, lid) {
+    return this.getLogInternal(id, lid);
+  }
+  async getLogInternal(id, lid) {
+    const pk = await this.keyBook.pubKey(id, lid);
+    if (!pk) {
+      throw db.Errors.ErrLogNotFound;
+    }
+    const sk = await this.keyBook.privKey(id, lid);
+    const addrs = await this.addrBook.addrs(id, lid);
+    const heads = await this.headBook.heads(id, lid);
+    const managed = await this.metadata.getBool(id, lid.toString() + managedSuffix);
+    return {
+      id: lid,
+      pubKey: pk,
+      ...(sk ? {
+        privKey: sk
+      } : {}),
+      addrs,
+      ...(heads.length > 0 ? {
+        head: heads[0]
+      } : {}),
+      managed: managed || false
+    };
+  }
+  // GetManagedLogs returns the logs the host is 'managing' under the given thread.
+  async getManagedLogs(id) {
+    const logs = await this.keyBook.logsWithKeys(id);
+    const managed = [];
+    for (const lid of logs) {
+      const lg = await this.getLog(id, lid);
+      if (lg.managed || lg.privKey) {
+        managed.push(lg);
+      }
+    }
+    return managed;
+  }
+  // DeleteLog deletes a log.
+  async deleteLog(id, lid) {
+    return this.mutex.runExclusive(async () => {
+      await this.keyBook.clearLogKeys(id, lid);
+      await this.addrBook.clearAddrs(id, lid);
+      await this.headBook.clearHeads(id, lid);
+    });
+  }
+}
+
+exports.PermanentAddrTTL = PermanentAddrTTL;
+exports.default = Logstore;
+exports.newLogstore = newLogstore;