mossring 1.0.1 → 2.0.0

package/README.md

@@ -1,50 +1,60 @@
-# anonymoustest
+# mossring
 
-用密钥文件对本地文件进行 **AES-256-GCM** 加密 / 解密的命令行工具。零第三方依赖，仅使用 Node.js 内置 `crypto`。
+非对称加密本地文件的命令行工具：**X25519 + AES-256-GCM**（密封盒 / sealed box）。零第三方依赖，仅用 Node.js 内置 `crypto`。
 
-隐私保护靠的是**真正的加密**，而不是改后缀或伪装——没有密钥，文件内容就是无法读取的密文。
+- **加密**用内置公钥，**无需指定任何密钥**，方便。
+- **解密**必须用你本地保存的**私钥**，安全。
+- 公钥可以公开（包里就内置了一个）；只有持有私钥的人能解密。
+
+> 隐私靠真正的加密，而非伪装。没有私钥，文件内容就是无法读取的密文。
 
 ## 安装
 
 ```bash
 npm install -g mossring
 # 或免安装直接用：
-npx mossring --help
+npx mossring help
 ```
 
 ## 使用
 
 ```bash
-# 1. 生成一把密钥（请离线备份）
-mossring keygen -o my.key
+# 用内置公钥加密 → 生成 secret.pdf.enc（不需要任何密钥）
+mossring encrypt secret.pdf
+
+# 用你的私钥解密
+mossring decrypt secret.pdf.enc -k mossring.priv
+```
 
-# 2. 加密文件 → 生成 secret.pdf.enc
-mossring encrypt secret.pdf -k my.key
+### 自己生成密钥对
 
-# 3. 解密 → 还原 secret.pdf
-mossring decrypt secret.pdf.enc -k my.key
+```bash
+mossring keygen -o mykey          # 生成 mykey.priv（私钥）和 mykey.pub（公钥）
+mossring encrypt data.zip -p mykey.pub   # 用指定公钥加密
+mossring decrypt data.zip.enc -k mykey.priv
 ```
 
 ### 选项
 
 | 选项 | 说明 |
 | --- | --- |
-| `-k, --key` | 密钥文件路径 |
+| `-p, --pub` | 接收方公钥文件（加密时不指定则用内置公钥） |
+| `-k, --key` | 私钥文件（解密时必需） |
 | `-o, --out` | 输出文件路径 |
 | `-f, --force` | 覆盖已存在的输出文件 |
 | `-h, --help` | 显示帮助 |
 
 ## 加密细节
 
-- **算法**：AES-256-GCM（带完整性校验，文件被篡改会在解密时报错）
-- **密钥派生**：每个文件用随机 16 字节 salt 经 HKDF-SHA256 派生独立子密钥，避免 IV 重用风险
-- **文件格式**：`MAGIC(5) | VERSION(1) | SALT(16) | IV(12) | TAG(16) | 密文`
-- **密钥**：256-bit 随机密钥，base64 存储于密钥文件（权限 `0600`）
+- **密钥协商**：X25519 ECDH，每次加密用一次性临时密钥对（前向保密）
+- **对称加密**：AES-256-GCM（带完整性校验，篡改会在解密时报错）
+- **密钥派生**：HKDF-SHA256，salt 绑定临时公钥与接收方公钥
+- **文件格式**：`MAGIC(5) | VERSION(1) | EPK_LEN(2) | 临时公钥 | IV(12) | TAG(16) | 密文`
 
 ## 重要提示
 
-- **密钥丢失 = 数据永久无法恢复**，请离线备份密钥文件。
-- 密钥文件不要和加密文件放在一起，也不要提交到代码仓库。
+- **私钥丢失 = 数据永久无法恢复**，请离线备份私钥文件。
+- 公钥可公开；私钥绝不要提交到仓库或发布到 npm。
 - 当前实现会将整个文件读入内存，超大文件请注意内存占用。
 
 ## License

package/bin/cli.js

@@ -1,27 +1,30 @@
 #!/usr/bin/env node
 import { readFileSync, writeFileSync, existsSync, chmodSync } from "node:fs";
 import { argv, exit } from "node:process";
-import { generateKey, encodeKey, decodeKey, encrypt, decrypt } from "../src/crypto.js";
+import { generateKeyPair, encrypt, decrypt } from "../src/crypto.js";
+import { BUILTIN_PUBLIC_KEY } from "../src/recipient.js";
 
-const HELP = `mossring — 用密钥文件加密/解密本地文件 (AES-256-GCM)
+const HELP = `mossring — 非对称加密本地文件 (X25519 + AES-256-GCM)
+
+加密用内置公钥，无需指定密钥；解密用你本地保存的私钥。
 
 用法:
-  mossring keygen [-o <密钥文件>] [-f]
-  mossring encrypt <文件> -k <密钥文件> [-o <输出>] [-f]
-  mossring decrypt <文件> -k <密钥文件> [-o <输出>] [-f]
+  mossring keygen [-o <前缀>] [-f]        生成密钥对（<前缀>.priv / <前缀>.pub）
+  mossring encrypt <文件> [-p <公钥文件>] [-o <输出>] [-f]
+  mossring decrypt <文件> -k <私钥文件> [-o <输出>] [-f]
 
 选项:
-  -k, --key    密钥文件路径
+  -p, --pub    指定接收方公钥文件（不指定则用内置公钥）
+  -k, --key    私钥文件路径（解密用）
   -o, --out    输出文件路径
   -f, --force  覆盖已存在的输出文件
   -h, --help   显示帮助
 
 示例:
-  mossring keygen -o my.key
-  mossring encrypt secret.pdf -k my.key        # 生成 secret.pdf.enc
-  mossring decrypt secret.pdf.enc -k my.key    # 还原 secret.pdf
+  mossring encrypt secret.pdf                 # 用内置公钥加密 → secret.pdf.enc
+  mossring decrypt secret.pdf.enc -k mossring.priv
 
-注意: 密钥文件丢失后，加密文件无法恢复，请务必离线备份。`;
+注意: 公钥可公开，私钥务必离线保存。私钥丢失 = 加密文件无法恢复。`;
 
 function fail(msg) {
   console.error("错误：" + msg);
@@ -34,6 +37,7 @@ function parseArgs(args) {
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a === "-k" || a === "--key") opts.key = args[++i];
+    else if (a === "-p" || a === "--pub") opts.pub = args[++i];
     else if (a === "-o" || a === "--out") opts.out = args[++i];
     else if (a === "-f" || a === "--force") opts.force = true;
     else if (a === "-h" || a === "--help") opts.help = true;
@@ -48,14 +52,9 @@ function ensureWritable(path, force) {
   }
 }
 
-function loadKey(keyPath) {
-  if (!keyPath) fail("缺少密钥文件，请用 -k <密钥文件> 指定");
-  if (!existsSync(keyPath)) fail(`密钥文件不存在：${keyPath}`);
-  try {
-    return decodeKey(readFileSync(keyPath, "utf8"));
-  } catch (e) {
-    return fail(e.message);
-  }
+function readKeyFile(path, what) {
+  if (!existsSync(path)) fail(`${what}不存在：${path}`);
+  return readFileSync(path, "utf8").trim();
 }
 
 const [, , cmd, ...rest] = argv;
@@ -73,44 +72,66 @@ if (opts.help) {
 }
 
 if (cmd === "keygen") {
-  const out = opts.out || "mossring.key";
-  ensureWritable(out, opts.force);
-  writeFileSync(out, encodeKey(generateKey()) + "\n", { mode: 0o600 });
+  const prefix = opts.out || "mossring";
+  const privPath = `${prefix}.priv`;
+  const pubPath = `${prefix}.pub`;
+  ensureWritable(privPath, opts.force);
+  ensureWritable(pubPath, opts.force);
+  const { publicKeyB64, privateKeyB64 } = generateKeyPair();
+  writeFileSync(privPath, privateKeyB64 + "\n", { mode: 0o600 });
   try {
-    chmodSync(out, 0o600);
+    chmodSync(privPath, 0o600);
   } catch {
-    /* Windows 等平台忽略权限设置 */
+    /* 非 POSIX 平台忽略 */
   }
-  console.log(`已生成密钥：${out}`);
-  console.log("⚠️  请离线备份此密钥。密钥丢失 = 加密文件永久无法恢复。");
+  writeFileSync(pubPath, publicKeyB64 + "\n");
+  console.log(`已生成密钥对：`);
+  console.log(`  私钥 → ${privPath}（请离线保存，切勿公开）`);
+  console.log(`  公钥 → ${pubPath}（可公开）`);
+  console.log("⚠️  私钥丢失 = 加密文件永久无法恢复。");
   exit(0);
 }
 
-if (cmd === "encrypt" || cmd === "decrypt") {
+if (cmd === "encrypt") {
   const input = positional[0];
   if (!input) fail("缺少输入文件");
   if (!existsSync(input)) fail(`输入文件不存在：${input}`);
-  const masterKey = loadKey(opts.key);
+  const pub = opts.pub ? readKeyFile(opts.pub, "公钥文件") : BUILTIN_PUBLIC_KEY;
+  if (!pub) {
+    fail("没有可用的公钥：包内未内置公钥，请用 -p <公钥文件> 指定，或先运行 mossring keygen");
+  }
+  const out = opts.out || input + ".enc";
+  ensureWritable(out, opts.force);
   const data = readFileSync(input);
+  let blob;
+  try {
+    blob = encrypt(data, pub);
+  } catch (e) {
+    fail(e.message);
+  }
+  writeFileSync(out, blob);
+  console.log(`已加密：${input} → ${out}`);
+  exit(0);
+}
 
-  if (cmd === "encrypt") {
-    const out = opts.out || input + ".enc";
-    ensureWritable(out, opts.force);
-    writeFileSync(out, encrypt(data, masterKey));
-    console.log(`已加密：${input} → ${out}`);
-  } else {
-    const out =
-      opts.out || (input.endsWith(".enc") ? input.slice(0, -4) : input + ".dec");
-    ensureWritable(out, opts.force);
-    let plain;
-    try {
-      plain = decrypt(data, masterKey);
-    } catch (e) {
-      fail(e.message);
-    }
-    writeFileSync(out, plain);
-    console.log(`已解密：${input} → ${out}`);
+if (cmd === "decrypt") {
+  const input = positional[0];
+  if (!input) fail("缺少输入文件");
+  if (!existsSync(input)) fail(`输入文件不存在：${input}`);
+  if (!opts.key) fail("缺少私钥文件，请用 -k <私钥文件> 指定");
+  const priv = readKeyFile(opts.key, "私钥文件");
+  const out =
+    opts.out || (input.endsWith(".enc") ? input.slice(0, -4) : input + ".dec");
+  ensureWritable(out, opts.force);
+  const data = readFileSync(input);
+  let plain;
+  try {
+    plain = decrypt(data, priv);
+  } catch (e) {
+    fail(e.message);
   }
+  writeFileSync(out, plain);
+  console.log(`已解密：${input} → ${out}`);
   exit(0);
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mossring",
-  "version": "1.0.1",
-  "description": "用密钥文件对本地文件进行 AES-256-GCM 加密/解密的命令行工具",
+  "version": "2.0.0",
+  "description": "非对称加密本地文件 (X25519 + AES-256-GCM)：内置公钥加密，本地私钥解密",
   "type": "module",
   "bin": {
     "mossring": "bin/cli.js"

package/src/crypto.js

@@ -1,47 +1,85 @@
-import { createCipheriv, createDecipheriv, randomBytes, hkdfSync } from "node:crypto";
+import {
+  createCipheriv,
+  createDecipheriv,
+  createPublicKey,
+  createPrivateKey,
+  generateKeyPairSync,
+  diffieHellman,
+  randomBytes,
+  hkdfSync,
+} from "node:crypto";
 
-// 文件格式：MAGIC(5) | VERSION(1) | SALT(16) | IV(12) | TAG(16) | CIPHERTEXT
-const MAGIC = Buffer.from("ANON1", "utf8");
-const VERSION = 1;
+// 非对称「密封盒」格式 v2（X25519 + AES-256-GCM）：
+// MAGIC(5) | VERSION(1) | EPK_LEN(2) | 临时公钥(DER) | IV(12) | TAG(16) | 密文
+const MAGIC = Buffer.from("ANON2", "utf8");
+const VERSION = 2;
 const KEY_LEN = 32; // AES-256
-const SALT_LEN = 16;
-const IV_LEN = 12; // GCM 推荐 96-bit
+const IV_LEN = 12;
 const TAG_LEN = 16;
-const HKDF_INFO = Buffer.from("anonymoustest/file-encryption/v1", "utf8");
+const HKDF_INFO = Buffer.from("mossring/sealed-box/v2", "utf8");
 
-// 生成一把全新的 256-bit 主密钥
-export function generateKey() {
-  return randomBytes(KEY_LEN);
+// 生成一对 X25519 密钥；公钥可公开内置，私钥务必本地保存
+export function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("x25519");
+  return {
+    publicKeyB64: publicKey.export({ type: "spki", format: "der" }).toString("base64"),
+    privateKeyB64: privateKey.export({ type: "pkcs8", format: "der" }).toString("base64"),
+  };
 }
 
-export function encodeKey(keyBuf) {
-  return keyBuf.toString("base64");
+function importPublicKey(b64) {
+  try {
+    return createPublicKey({
+      key: Buffer.from(String(b64).trim(), "base64"),
+      format: "der",
+      type: "spki",
+    });
+  } catch {
+    throw new Error("无效的公钥");
+  }
 }
 
-export function decodeKey(text) {
-  const buf = Buffer.from(String(text).trim(), "base64");
-  if (buf.length !== KEY_LEN) {
-    throw new Error(`无效的密钥文件：期望 ${KEY_LEN} 字节，实际 ${buf.length} 字节`);
+function importPrivateKey(b64) {
+  try {
+    return createPrivateKey({
+      key: Buffer.from(String(b64).trim(), "base64"),
+      format: "der",
+      type: "pkcs8",
+    });
+  } catch {
+    throw new Error("无效的私钥文件");
   }
-  return buf;
 }
 
-// 每个文件用随机 salt 派生独立子密钥，避免在同一主密钥下重用 IV 的风险
-function deriveKey(masterKey, salt) {
-  return Buffer.from(hkdfSync("sha256", masterKey, salt, HKDF_INFO, KEY_LEN));
+// 把双方公钥并入 HKDF 的 salt，将密钥绑定到本次收发上下文
+function deriveKey(sharedSecret, ephemeralPubDer, recipientPubDer) {
+  const salt = Buffer.concat([ephemeralPubDer, recipientPubDer]);
+  return Buffer.from(hkdfSync("sha256", sharedSecret, salt, HKDF_INFO, KEY_LEN));
 }
 
-export function encrypt(plaintext, masterKey) {
-  const salt = randomBytes(SALT_LEN);
+export function encrypt(plaintext, recipientPubB64) {
+  const recipientPub = importPublicKey(recipientPubB64);
+  const recipientPubDer = recipientPub.export({ type: "spki", format: "der" });
+
+  // 每次加密用一把一次性临时密钥对，保证前向保密
+  const eph = generateKeyPairSync("x25519");
+  const ephPubDer = eph.publicKey.export({ type: "spki", format: "der" });
+
+  const shared = diffieHellman({ privateKey: eph.privateKey, publicKey: recipientPub });
+  const key = deriveKey(shared, ephPubDer, recipientPubDer);
+
   const iv = randomBytes(IV_LEN);
-  const key = deriveKey(masterKey, salt);
   const cipher = createCipheriv("aes-256-gcm", key, iv);
   const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
   const tag = cipher.getAuthTag();
-  return Buffer.concat([MAGIC, Buffer.from([VERSION]), salt, iv, tag, ciphertext]);
+
+  const epkLen = Buffer.alloc(2);
+  epkLen.writeUInt16BE(ephPubDer.length);
+
+  return Buffer.concat([MAGIC, Buffer.from([VERSION]), epkLen, ephPubDer, iv, tag, ciphertext]);
 }
 
-export function decrypt(blob, masterKey) {
+export function decrypt(blob, privateKeyB64) {
   let offset = 0;
   const magic = blob.subarray(offset, (offset += MAGIC.length));
   if (!magic.equals(MAGIC)) {
@@ -52,16 +90,25 @@ export function decrypt(blob, masterKey) {
   if (version !== VERSION) {
     throw new Error(`不支持的文件版本：${version}`);
   }
-  const salt = blob.subarray(offset, (offset += SALT_LEN));
+  const epkLen = blob.readUInt16BE(offset);
+  offset += 2;
+  const ephPubDer = Buffer.from(blob.subarray(offset, (offset += epkLen)));
   const iv = blob.subarray(offset, (offset += IV_LEN));
   const tag = blob.subarray(offset, (offset += TAG_LEN));
   const ciphertext = blob.subarray(offset);
-  const key = deriveKey(masterKey, salt);
+
+  const priv = importPrivateKey(privateKeyB64);
+  const recipientPubDer = createPublicKey(priv).export({ type: "spki", format: "der" });
+  const ephPub = createPublicKey({ key: ephPubDer, format: "der", type: "spki" });
+
+  const shared = diffieHellman({ privateKey: priv, publicKey: ephPub });
+  const key = deriveKey(shared, ephPubDer, recipientPubDer);
+
   const decipher = createDecipheriv("aes-256-gcm", key, iv);
   decipher.setAuthTag(tag);
   try {
     return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
   } catch {
-    throw new Error("解密失败：密钥不正确，或文件已损坏/被篡改");
+    throw new Error("解密失败：私钥不匹配，或文件已损坏/被篡改");
   }
 }

package/src/recipient.js

@@ -0,0 +1,3 @@
+// 内置的接收方公钥（X25519, SPKI/DER 的 base64）。
+// 公钥可公开，仅用于「加密给你」；解密必须用你本地保存的私钥 mossring.priv。
+export const BUILTIN_PUBLIC_KEY = "MCowBQYDK2VuAyEA47OpkVNetZE6UWKuJxH3EV/YbzVR66jV89L6SjODhQs=";