@tacet-ink/journal-core 0.1.4 → 0.1.6

package/src/client/argon2.ts

@@ -16,7 +16,7 @@
  * AAD 與長度把關，跨前綴呼叫一律回 null（unwrap 有前綴守衛，驗證閘有跨協議斷言）。
  *
  * 雙載體（同一 spec 兩端一致，交叉驗證逐位元一致）：
- * - node（驗證閘/prod smoke）：node:crypto.argon2（Node 26 原生，26.8.1 實測）
+ * - node（驗證閘/prod smoke）：node:crypto.argon2（24.7.0 落地版，26.8.1 實測）
  * - 瀏覽器：hash-wasm argon2id（純 wasm 內嵌 base64，零網路請求，4.12.0 實測 64MiB t=3 ≈ 180ms）
  * 標準向量：RFC 9106 無 secret/associated-data Argon2id（t=3, m=32, p=4, pwd=32B 0x01, salt=16B 0x00）
  *   = 72d2a36fd5c266bcc96121b24937bc253338cdfcbd273713655748c54b4dd503（兩載體實測 MATCH）。
@@ -29,9 +29,9 @@
  * ⚠️ wrappedRec（復原套件）維持 jr1w.：recToken 是 256-bit 實體因子，KDF 強度無意義，不動。
  */
 
-import { IV_LEN, normalizePin } from './note-crypto.ts';
+import { normalizePin } from './note-crypto.ts';
 import {
-  b64, unb64, toHex, hexToBytes, encryptWithKey, decryptWithKey, importAesGcm,
+  b64, unb64, toHex, hexToBytes, decryptWithKey, importAesGcm, openNoteKey, sealNoteKey,
 } from './note-crypto.ts';
 
 /** RFC 9106 無 secret/ad 標準向量（Argon2id v=0x13, t=3, m=32, p=4, T=32, pwd=32B 0x01, salt=16B 0x00）。 */
@@ -54,10 +54,12 @@ export const PH1_V2_SALT = 'tacet-ph1-v1';
  * 重算 sha256(sha256(g)) 對 ph2 命中即 g 是密語）。ph1 改 Argon2id 派生後每猜成本
  * ×10⁴-10⁶。參數沿 jr3w. 同一組常數（單一碼路）；無載體即 throw（禁 fallback 鐵律）。
  */
-export async function derivePh1Argon(passphrase: string): Promise<string> {
+export async function derivePh1Argon(passphrase: string, saltArg?: Uint8Array): Promise<string> {
+  // PH1 鹽可注入（t_7710c766 目標 4）：預設 PH1_V2_SALT 舊值＝tacet 零行為變更；
+  // 其他產品可自選鹽但 per-product 恆固定（PH2 UNIQUE 約束——per-user 鹽會摧毀它）。
   return toHex(await deriveArgon2id(
     passphrase,
-    new TextEncoder().encode(PH1_V2_SALT),
+    saltArg ?? new TextEncoder().encode(PH1_V2_SALT),
     ARGON_MEMORY_KIB,
     ARGON_ITERATIONS,
     ARGON_PARALLELISM,
@@ -195,24 +197,21 @@ export async function wrapNoteKey3(cfg: Argon3Config, noteKey: CryptoKey, passph
   if (!cfg.wrap3) throw new Error('ERR_JR3W_NOT_CONFIGURED');
   const salt = crypto.getRandomValues(new Uint8Array(SALT_LEN));
   const kek = await deriveKekArgon(passphrase, salt);
-  const rawHex = toHex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
-  const wrapped = cfg.wrap3 + await encryptWithKey(kek, rawHex, 'notekey');
+  const wrapped = await sealNoteKey(cfg.wrap3, noteKey, kek, 'notekey');
   return { wrapped, salt: toHex(salt) };
 }
 
-/** jr3w. 解包：任何不符（前綴/salt 形/長度/AAD）回 null 不拋；成功 → noteKey extractable=true（鐵律 4）。 */
+/** jr3w. 解包：任何不符（前綴/salt 形/長度/AAD）回 null 不拋；成功 → noteKey extractable=true（鐵律 4）。
+ *  收口 openNoteKey（t_7710c766）：嚴格 92B＋rawHex 形＋hex fail-closed 全在共用核心；本函式只做
+ *  家族守衛（wrap3 未配置回 null）、salt1 hex-形檢查與 KEK 派生——payload 形是鹽外置家族（iv‖ct），
+ *  own 92B 檢已隨收口摘除（jr3s 同；鹽內嵌族 own 108B 保留）。 */
 export async function unwrapNoteKey3(cfg: Argon3Config, wrapped: string, passphrase: string, saltHex: string): Promise<CryptoKey | null> {
   try {
-    if (!cfg.wrap3 || !wrapped.startsWith(cfg.wrap3)) return null;
+    if (!cfg.wrap3) return null;
     const salt = hexToBytes(saltHex);
     if (salt.length !== SALT_LEN || !/^[0-9a-f]{32}$/.test(saltHex)) return null;
-    const payload = unb64(wrapped.slice(cfg.wrap3.length));
-    // 嚴格長度：iv(12) + ct(hex(noteKey) 64B + GCM tag 16B) = 92B 固定（salt 在 users.salt 不內嵌）
-    if (payload.length !== IV_LEN + 80) return null;
     const kek = await deriveKekArgon(passphrase, salt);
-    const rawHex = await decryptWithKey(kek, payload, 'notekey');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true);
+    return await openNoteKey(wrapped, kek, 'notekey', cfg.wrap3);
   } catch {
     return null;
   }
@@ -234,6 +233,9 @@ async function deriveKek2Argon(
   pinSalt: Uint8Array,
 ): Promise<CryptoKey> {
   if (!cfg.pinSalt3Prefix) throw new Error('ERR_JR3W_NOT_CONFIGURED');
+  // ⚠️ 瀏覽器 hash-wasm Argon2 禁並行（t_7361b68c）：純 wasm Argon2id 共享記憶體池，
+  // 兩實例並行在部分引擎靜態直 throw——這裡故意保持串行（與 jr2w. PBKDF2 版
+  // deriveKek2 的 Promise.all 並行不同：那裡並行的前提是 crypto.subtle 原生派生）。
   const passBits = await deriveArgon2id(passphrase, salt1, ARGON_MEMORY_KIB, ARGON_ITERATIONS, ARGON_PARALLELISM);
   const pinBits = await deriveArgon2id(
     pinNorm,
@@ -256,24 +258,18 @@ async function deriveKek2Argon(
 }
 
 /** jr3d. 包裹：payload = pinSalt[16] ‖ iv[12] ‖ GCM(KEK2, hex(noteKey), aad='notekey2')；salt1 由呼叫端存 users.salt。 */
-export async function wrapNoteKeyDual3(
-  cfg: Argon3Config,
-  noteKey: CryptoKey,
-  passphrase: string,
-  pin: string,
-): Promise<{ wrapped: string; salt: string }> {
+export async function wrapNoteKeyDual3(cfg: Argon3Config, noteKey: CryptoKey, passphrase: string, pin: string): Promise<{ wrapped: string; salt: string }> {
   if (!cfg.wrapDual3 || !cfg.pinSalt3Prefix) throw new Error('ERR_JR3W_NOT_CONFIGURED');
   const pinNorm = normalizePin(pin);
-  if (!pinNorm) throw new Error('ERR_JR3W_NOT_CONFIGURED');
+  if (!pinNorm) throw new Error('ERR_PIN_EMPTY');
   const salt1 = crypto.getRandomValues(new Uint8Array(SALT_LEN));
   const pinSalt = crypto.getRandomValues(new Uint8Array(DUAL_SALT_LEN));
   const kek2 = await deriveKek2Argon(cfg, passphrase, pinNorm, salt1, pinSalt);
   const iv = crypto.getRandomValues(new Uint8Array(DUAL_IV_LEN));
-  const rawHex = toHex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
   const ct = new Uint8Array(await crypto.subtle.encrypt(
     { name: 'AES-GCM', iv, additionalData: new TextEncoder().encode('notekey2') as BufferSource },
     kek2,
-    new TextEncoder().encode(rawHex) as BufferSource,
+    new TextEncoder().encode(toHex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)))) as BufferSource,
   ));
   const payload = new Uint8Array(DUAL_SALT_LEN + DUAL_IV_LEN + ct.byteLength);
   payload.set(pinSalt, 0);
@@ -282,7 +278,10 @@ export async function wrapNoteKeyDual3(
   return { wrapped: cfg.wrapDual3 + b64(payload), salt: toHex(salt1) };
 }
 
-/** jr3d. 解包：pinSalt 內嵌自描述，salt1 取自 login 回應；任何不符回 null，不拋。 */
+/** jr3d. 解包：pinSalt 內嵌自描述，salt1 取自 login 回應；任何不符回 null，不拋。
+ *  t_7710c766：嚴格檢查為鹽內嵌族自有——payload 嚴格 108B（pinSalt 16
+ *  ＋ iv 12＋ct 80）＋ decryptWithKey 後 rawHex hex 形檢查（hexToBytes fail-closed），
+ *  不經 openNoteKey 本體（鹽外置 92B 形）；與 openNoteKey 同嚴格度。 */
 export async function unwrapNoteKeyDual3(
   cfg: Argon3Config,
   wrapped: string,
@@ -296,7 +295,7 @@ export async function unwrapNoteKeyDual3(
     const salt1 = hexToBytes(salt1Hex);
     if (salt1.length !== SALT_LEN || !/^[0-9a-f]{32}$/.test(salt1Hex)) return null;
     const payload = unb64(wrapped.slice(cfg.wrapDual3.length));
-    // 嚴格長度：pinSalt(16) + iv(12) + ct(hex(noteKey) 64B + GCM tag 16B) = 108B 固定
+    // 嚴格長度：pinSalt(16) + iv(12) + ct(hex 字串 64B + GCM tag 16B) = 108B 固定
     if (payload.length !== DUAL_SALT_LEN + DUAL_IV_LEN + 80) return null;
     const pinSalt = payload.slice(0, DUAL_SALT_LEN);
     const ivPrefixedCt = payload.slice(DUAL_SALT_LEN); // decryptWithKey 契約：payload = iv[12] ‖ ct
@@ -304,7 +303,7 @@ export async function unwrapNoteKeyDual3(
     if (!pinNorm) return null;
     const kek2 = await deriveKek2Argon(cfg, passphrase, pinNorm, salt1, pinSalt);
     const rawHex = await decryptWithKey(kek2, ivPrefixedCt, 'notekey2');
-    if (!rawHex) return null;
+    if (!rawHex || rawHex.length !== 64 || !/^[0-9a-f]+$/.test(rawHex)) return null;
     return importAesGcm(hexToBytes(rawHex), true); // extractable=true：要能再包裹（鐵律）
   } catch {
     return null;
@@ -326,24 +325,20 @@ export async function wrapNoteKeyShare3(cfg: Argon3Config, noteKey: CryptoKey, s
   if (!cfg.wrapShare3) throw new Error('ERR_JR3S_NOT_CONFIGURED');
   const salt = crypto.getRandomValues(new Uint8Array(SALT_LEN));
   const kek = await deriveKekArgon(sharePass, salt);
-  const rawHex = toHex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
-  const wrapped = cfg.wrapShare3 + await encryptWithKey(kek, rawHex, 'notekey-share');
+  const wrapped = await sealNoteKey(cfg.wrapShare3, noteKey, kek, 'notekey-share');
   return { wrapped, salt: toHex(salt) };
 }
 
-/** jr3s. 解包：salt 取自 GET /shares/:hash 回應（與 jr1w 同形）；任何不符回 null，不拋。 */
+/** jr3s. 解包：salt 取自 GET /shares/:hash 回應（與 jr1w 同形）；任何不符回 null，不拋。
+ *  收口 openNoteKey（t_7710c766）：鹽外置家族（payload 嚴格 92B＋rawHex 形＋hex fail-closed
+ *  全在共用核心）；本函式只做家族守衛、salt hex-形檢查與 KEK 派生——own 92B 檢已隨收口摘除。 */
 export async function unwrapNoteKeyShare3(cfg: Argon3Config, wrapped: string, sharePass: string, saltHex: string): Promise<CryptoKey | null> {
   try {
-    if (!cfg.wrapShare3 || !wrapped.startsWith(cfg.wrapShare3)) return null;
+    if (!cfg.wrapShare3) return null;
     const salt = hexToBytes(saltHex);
     if (salt.length !== SALT_LEN || !/^[0-9a-f]{32}$/.test(saltHex)) return null;
-    const payload = unb64(wrapped.slice(cfg.wrapShare3.length));
-    // 嚴格長度：iv(12) + ct(hex(noteKey) 64B + GCM tag 16B) = 92B 固定（salt 在 shares.salt 不內嵌）
-    if (payload.length !== IV_LEN + 80) return null;
     const kek = await deriveKekArgon(sharePass, salt);
-    const rawHex = await decryptWithKey(kek, payload, 'notekey-share');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true); // extractable=true：解出後要能解日記密文（鐵律）
+    return await openNoteKey(wrapped, kek, 'notekey-share', cfg.wrapShare3);
   } catch {
     return null;
   }

package/src/client/note-crypto.ts

@@ -52,12 +52,25 @@ export const PIN_PBKDF2_ITERATIONS = 2_000_000; // 雙因子 pin 段（設計 v2
 export const IV_LEN = 12;
 
 const HEX32_RE = /^[0-9a-f]{32}$/; // 16-byte salt hex
+/**
+ * hex 合法性（fail-closed 目標 #2）：大小寫正規化後長度恰 2n（n bytes＝2 hex digits×n）＋
+ * 每雙位元組真 hex。
+ */
+const HEX_RE = /^([0-9a-f][0-9a-f])+$/;
 
 // ── 基礎工具（export 供 argon2.ts 等同檔模組複用；語意不變） ─────────────────
 
 export function b64(bytes: Uint8Array): string {
+  // 分塊 String.fromCharCode.apply（t_7361b68c 目標 2：review 實測瀏覽器 4MiB 222ms→27ms；
+  // node 端分塊形 132-181ms→18ms，與閘執行帳同源——review 的 Node-only toBase64 1ms 帳是
+  // 不同形，非本體帳：round 2 MINOR-2 對齊）。瀏覽器端恆走本形——core 是 isomorphic TS
+  // 源碼發行，不引入 Node-only
+  // toBase64 分支（卡面否決案）。apply 參數上限安全窗 8192；輸出 byte 等價
+  // （驗證閘 [14] 有 0/1/7/8191/8192/8193/65539 邊界逐位元組對照＋unb64 roundtrip）。
   let binary = '';
-  for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+  for (let i = 0; i < bytes.byteLength; i += 8192) {
+    binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 8192) as unknown as number[]);
+  }
   return btoa(binary);
 }
 
@@ -73,7 +86,22 @@ export function toHex(bytes: Uint8Array): string {
 }
 
 export function hexToBytes(hex: string): Uint8Array {
-  return new Uint8Array((hex.match(/.{2}/g) ?? []).map(h => parseInt(h, 16)));
+  // fail-closed（目標 #2）：非法字元靜默歸零是 unwrap 家族的假金鑰生產器——
+  // 拋 ERR_BAD_HEX（呼叫端 unwrap 全部 try/catch 回 null；非 catch 端僅 bip39
+  // HEX64_RE 前置自守）。奇數長度、非 hex、空字串皆拒；大小寫/全形 NFKC 收容。
+  // 測與 parse 同一（正規化後）真相——round 1 審查 MINOR-4：形檢吃正規化串、
+  // parseInt 吃原始串＝全形 hex digit NaN 歸零殘形（README 例外契約自穿透），收口殲滅。
+  // NFKC 寬容＝設計面刻意（round 2 NIT 記錄 t_580f9c54）：'⑩'→'10' 等相容字元收容後是真 hex
+  // 值（⑩→[16] 實帳），非缺陷形（NaN 歸零已殲滅＝輸出恆數學等值）；rawHex 檢查同式（HEX_RE 同行後置
+  // ＝rawHex 前置守衛）；鹽欄同為同行後置（note-crypto/argon2 各 unwrap 面鹽欄形檢——行號帳不寫死，
+  // 新增段推移行號＝註解行號帳漂移，NIT-a 同病禁再犯）。
+  // 行為恆 null（純註解）；正式輸入面形檢在場，公開原語只保證「正規化後真 hex 恆等值、垃圾恆拒」。
+  // 若要 ASCII-only 收緊＝帶內版本化（換前綴），禁原地改語意。
+  const norm = hex.normalize('NFKC').toLowerCase();
+  if (!HEX_RE.test(norm)) {
+    throw new Error('ERR_BAD_HEX');
+  }
+  return new Uint8Array((norm.match(/.{2}/g) ?? []).map(h => parseInt(h, 16)));
 }
 
 async function sha256Hex(text: string): Promise<string> {
@@ -98,6 +126,8 @@ export async function deriveGuestKey(cfg: NoteCryptoConfig, identity: string): P
 }
 
 async function deriveKek(password: string, salt: Uint8Array): Promise<CryptoKey> {
+  // 這裡的 importKey 是 deriveKey 用途集——與 derivePbkdf2Bits 的 deriveBits 面不是同一形，
+  // 禁共用 importKeyRawForKdf（usage 不符＝InvalidAccessError；t_7361b68c probe 實證）。
   const keyMat = await crypto.subtle.importKey('raw', new TextEncoder().encode(password) as BufferSource, 'PBKDF2', false, ['deriveKey']);
   return crypto.subtle.deriveKey(
     { name: 'PBKDF2', salt: salt as BufferSource, iterations: PBKDF2_ITERATIONS, hash: 'SHA-256' },
@@ -108,6 +138,11 @@ async function deriveKek(password: string, salt: Uint8Array): Promise<CryptoKey>
   );
 }
 
+/** raw → PBKDF2 import（僅供 deriveBits 用途；與 deriveKek 的 deriveKey 用途分行）。 */
+async function importKeyRawForKdf(password: string): Promise<CryptoKey> {
+  return crypto.subtle.importKey('raw', new TextEncoder().encode(password) as BufferSource, 'PBKDF2', false, ['deriveBits']);
+}
+
 // ── 雙因子合鑰（jr2w.，PIN 第二因子；2026-09-09 定案 v2） ────────────────────
 //
 // KEK2 = HKDF-SHA256( ikm = PBKDF2(pass, salt1, 600k)[32B] ‖ PBKDF2(pin, pinSaltPrefix‖pinSalt, 2M)[32B],
@@ -123,14 +158,22 @@ export function normalizePin(pin: string): string {
 }
 
 async function derivePbkdf2Bits(password: string, salt: Uint8Array, iterations: number): Promise<Uint8Array> {
-  const keyMat = await crypto.subtle.importKey('raw', new TextEncoder().encode(password) as BufferSource, 'PBKDF2', false, ['deriveBits']);
-  const bits = await crypto.subtle.deriveBits({ name: 'PBKDF2', salt: salt as BufferSource, iterations, hash: 'SHA-256' }, keyMat, 256);
+  const km = await importKeyRawForKdf(password);
+  const bits = await crypto.subtle.deriveBits({ name: 'PBKDF2', salt: salt as BufferSource, iterations, hash: 'SHA-256' }, km, 256);
   return new Uint8Array(bits);
 }
 
 async function deriveKek2(cfg: NoteCryptoConfig, passphrase: string, pin: string, salt1: Uint8Array, pinSalt: Uint8Array): Promise<CryptoKey> {
-  const passBits = await derivePbkdf2Bits(passphrase, salt1, PBKDF2_ITERATIONS);
-  const pinBits = await derivePbkdf2Bits(pin, new TextEncoder().encode(cfg.pinSaltPrefix + toHex(pinSalt)), PIN_PBKDF2_ITERATIONS);
+  // pass 段與 pin 段 PBKDF2 相互獨立（不同 salt/密碼不同鹽源）＝可並行（t_7361b68c 目標 1）。
+  // ⚠️ 瀏覽器 hash-wasm Argon2（jr3d. 對應形 deriveKek2Argon）禁並行——純 wasm Argon2id
+  // 共享記憶體池、兩實例並行在部分引擎靜態直 throw，卡面 review 明示；並行只收 PBKDF2 家族。
+  // 兩段各自 importKeyRawForKdf（round 2 NIT-2：keyMat 參數化退場——pass/pin 段絕不共享 PBKDF2 基材）。
+  // 輸出序＝ikm 組裝序＝passBits@0 ‖ pinBits@32（與原串行逐位一致）；閘錨綁左手側 destructure，
+  // 對調滑接＝既有 jr2w. 帳戶全不可解（round 2 MAJOR-1 reviewer rev-harm 一手實證）。
+  const [passBits, pinBits] = await Promise.all([
+    derivePbkdf2Bits(passphrase, salt1, PBKDF2_ITERATIONS),
+    derivePbkdf2Bits(pin, new TextEncoder().encode(cfg.pinSaltPrefix + toHex(pinSalt)), PIN_PBKDF2_ITERATIONS),
+  ]);
   const ikm = new Uint8Array(passBits.byteLength + pinBits.byteLength);
   ikm.set(passBits, 0);
   ikm.set(pinBits, passBits.byteLength);
@@ -151,7 +194,7 @@ const DUAL_IV_LEN = 12;
 export async function wrapNoteKeyDual(cfg: NoteCryptoConfig, noteKey: CryptoKey, passphrase: string, pin: string): Promise<{ wrapped: string; salt: string }> {
   if (!cfg.wrapDual || !cfg.pinSaltPrefix) throw new Error('ERR_DUAL_NOT_CONFIGURED');
   const pinNorm = normalizePin(pin);
-  if (!pinNorm) throw new Error('ERR_DUAL_NOT_CONFIGURED');
+  if (!pinNorm) throw new Error('ERR_PIN_EMPTY'); // 空 PIN ≠ 未配置（t_7710c766 語意分離）
   const salt1 = crypto.getRandomValues(new Uint8Array(16));
   const pinSalt = crypto.getRandomValues(new Uint8Array(DUAL_SALT_LEN));
   const kek2 = await deriveKek2(cfg, passphrase, pinNorm, salt1, pinSalt);
@@ -175,9 +218,9 @@ export async function unwrapNoteKeyDual(cfg: NoteCryptoConfig, wrapped: string,
     if (!cfg.wrapDual || !cfg.pinSaltPrefix) return null;
     if (!wrapped.startsWith(cfg.wrapDual)) return null;
     const salt1 = hexToBytes(salt1Hex);
-    if (salt1.length !== 16) return null;
+    if (salt1.length !== 16 || !HEX32_RE.test(salt1Hex)) return null;
     const payload = unb64(wrapped.slice(cfg.wrapDual.length));
-    // 嚴格長度：pinSalt(16) + iv(12) + ct(hex(noteKey) 64B + GCM tag 16B) = 108B 固定
+    // 嚴格長度：pinSalt(16) + iv(12) + ct(hex 字串 64B + GCM tag 16B) = 108B 固定；rawHex hex 形為本函式自有檢查（鹽內嵌族不經 openNoteKey 本體）
     if (payload.length !== DUAL_SALT_LEN + DUAL_IV_LEN + 80) return null;
     const pinSalt = payload.slice(0, DUAL_SALT_LEN);
     const ivPrefixedCt = payload.slice(DUAL_SALT_LEN); // decryptWithKey 契約：payload = iv[12] ‖ ct
@@ -185,7 +228,7 @@ export async function unwrapNoteKeyDual(cfg: NoteCryptoConfig, wrapped: string,
     if (!pinNorm) return null;
     const kek2 = await deriveKek2(cfg, passphrase, pinNorm, salt1, pinSalt);
     const rawHex = await decryptWithKey(kek2, ivPrefixedCt, 'notekey2');
-    if (!rawHex) return null;
+    if (!rawHex || rawHex.length !== 64 || !/^[0-9a-f]+$/.test(rawHex)) return null;
     return importAesGcm(hexToBytes(rawHex), true); // extractable=true：要能再包裹（鐵律）
   } catch {
     return null;
@@ -291,24 +334,64 @@ export function recTokenHash(recToken: string): Promise<string> {
 
 // ── 金鑰包裹 ────────────────────────────────────────────────────────────────
 
+/** noteKey raw hex 長度（hex(noteKey) 64B ＝ payload ct 面 80B 契約的一半）。 */
+const NOTEKEY_HEX_LEN = 64;
+
+/**
+ * 共用包裹核心（目標 #1 收口）：prefix + b64(iv[12] ‖ GCM(KEK, hex(noteKey), aad))。
+ * 全家族單因子包裹（jr1w./jrsw./jr3w./jr3s.）與復原套件（wrappedRec，前綴共用 cfg.wrap）
+ * 同一本體；KDF 差異在呼叫端 KEK、payload 形狀（salt 外置 vs 內嵌）由各家族維持。
+ * prefix null/undefined＝未配置拒絕（呼叫端亦可先行拒絕，帶自家錯誤碼形；雙防線）。
+ */
+export async function sealNoteKey(prefix: string | null | undefined, noteKey: CryptoKey, kek: CryptoKey, aad: string): Promise<string> {
+  if (!prefix) throw new Error('ERR_WRAP_NOT_CONFIGURED');
+  const raw = await crypto.subtle.exportKey('raw', noteKey);
+  if (raw.byteLength !== 32) throw new Error('ERR_WRAPTAMPER_LEN32');
+  return prefix + await encryptWithKey(kek, toHex(new Uint8Array(raw)), aad);
+}
+
+/**
+ * 共用解包核心（目標 #1 收口）：任何不符——前綴、base64 形、payload 長度、
+ * GCM（金鑰/AAD/密文損壞）、rawHex 長度/hex 形——恆回 null 不拋。
+ * round 1 審查 MINOR-5：atob 對非法字元會拋、原 docstring「不拋」與實作不符——
+ * 本體吞收 null（公開原語誠實契約；呼叫端 unwrap 家族 try/catch 是雙防線非依賴面）。
+ * 家族嚴格度收口實況（round 1 審查 MINOR-2 校正＋r2 MINOR-1 殘餘校正 t_580f9c54）：
+ * 鹽外置 6 點由本體嚴格 92B 終結——note-crypto 四點（unwrapNoteKey＝jr1w／
+ * unwrapNoteKeyShare＝jrsw／unwrapNoteKeyWithRecToken＝jr1wRec 同本體／loadLocalWrap）
+ * ＋argon2 兩點（unwrapNoteKey3＝jr3w／unwrapNoteKeyShare3＝jr3s；own 92B 檢已隨收口摘除）；
+ * 鹽內嵌 3 點（jr2w/jr3d/jr1p）own 108B＋rawHex 形檢——與本體同嚴格度、刻意不經本體
+ * （pinSalt 前綴不在鹽外置形契約內）。維護本體時鹽內嵌三族不隨行。
+ */
+export async function openNoteKey(wrapped: string, kek: CryptoKey, aad: string, prefix: string): Promise<CryptoKey | null> {
+  if (!wrapped.startsWith(prefix)) return null;
+  let payload: Uint8Array;
+  try {
+    payload = unb64(wrapped.slice(prefix.length)); // atob 非法字元拋點吞收 null（公開原語全 null 契約）
+  } catch {
+    return null; // 壞 base64＝任何不符面之一（行為閘有壞 b64 向量承載）
+  }
+  if (payload.length !== IV_LEN + 80) return null; // 嚴格 92B：iv 12＋ct 80（hex64 字串編碼 64B＋tag 16）
+  const rawHex = await decryptWithKey(kek, payload, aad);
+  if (!rawHex || rawHex.length !== NOTEKEY_HEX_LEN || !HEX_RE.test(rawHex)) return null;
+  return importAesGcm(hexToBytes(rawHex), true); // extractable=true：要能再包裹/解密（鐵律）
+}
+
 /** passphrase 包裹：salt 隨機 16 bytes（hex 存於 users.salt）。 */
 export async function wrapNoteKey(cfg: NoteCryptoConfig, noteKey: CryptoKey, passphrase: string): Promise<{ wrapped: string; salt: string }> {
   const salt = crypto.getRandomValues(new Uint8Array(16));
+  if (!cfg.wrap) throw new Error('ERR_WRAP_NOT_CONFIGURED');
   const kek = await deriveKek(passphrase, salt);
-  const payload = new Uint8Array(await crypto.subtle.exportKey('raw', noteKey));
-  const wrapped = cfg.wrap + await encryptWithKey(kek, toHex(payload), 'notekey');
+  const wrapped = await sealNoteKey(cfg.wrap, noteKey, kek, 'notekey');
   return { wrapped, salt: toHex(salt) };
 }
 
 export async function unwrapNoteKey(cfg: NoteCryptoConfig, wrapped: string, passphrase: string, saltHex: string): Promise<CryptoKey | null> {
   try {
-    if (!wrapped.startsWith(cfg.wrap)) return null;
+    if (!cfg.wrap) return null;
     const salt = hexToBytes(saltHex);
     if (salt.length !== 16 || !HEX32_RE.test(saltHex)) return null;
     const kek = await deriveKek(passphrase, salt);
-    const rawHex = await decryptWithKey(kek, unb64(wrapped.slice(cfg.wrap.length)), 'notekey');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true); // extractable=true：要能再包裹
+    return await openNoteKey(wrapped, kek, 'notekey', cfg.wrap);
   } catch {
     return null;
   }
@@ -326,8 +409,7 @@ export async function wrapNoteKeyShare(cfg: NoteCryptoConfig, noteKey: CryptoKey
   if (!cfg.wrapShare) throw new Error('ERR_SHARE_NOT_CONFIGURED');
   const salt = crypto.getRandomValues(new Uint8Array(16));
   const kek = await deriveKek(sharePass, salt);
-  const payload = new Uint8Array(await crypto.subtle.exportKey('raw', noteKey));
-  const wrapped = cfg.wrapShare + await encryptWithKey(kek, toHex(payload), 'notekey-share');
+  const wrapped = await sealNoteKey(cfg.wrapShare, noteKey, kek, 'notekey-share');
   return { wrapped, salt: toHex(salt) };
 }
 
@@ -335,13 +417,10 @@ export async function wrapNoteKeyShare(cfg: NoteCryptoConfig, noteKey: CryptoKey
 export async function unwrapNoteKeyShare(cfg: NoteCryptoConfig, wrapped: string, sharePass: string, saltHex: string): Promise<CryptoKey | null> {
   try {
     if (!cfg.wrapShare) return null;
-    if (!wrapped.startsWith(cfg.wrapShare)) return null;
     const salt = hexToBytes(saltHex);
     if (salt.length !== 16 || !HEX32_RE.test(saltHex)) return null;
     const kek = await deriveKek(sharePass, salt);
-    const rawHex = await decryptWithKey(kek, unb64(wrapped.slice(cfg.wrapShare.length)), 'notekey-share');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true); // extractable=true：解出後要能解日記密文（鐵律）
+    return await openNoteKey(wrapped, kek, 'notekey-share', cfg.wrapShare);
   } catch {
     return null;
   }
@@ -354,23 +433,27 @@ async function deriveRecKek(cfg: NoteCryptoConfig, recToken: string, identity: s
 
 export async function wrapNoteKeyWithRecToken(cfg: NoteCryptoConfig, noteKey: CryptoKey, recToken: string, identity: string): Promise<string> {
   const kek = await deriveRecKek(cfg, recToken, identity);
-  const payload = new Uint8Array(await crypto.subtle.exportKey('raw', noteKey));
-  return cfg.wrap + await encryptWithKey(kek, toHex(payload), 'notekey');
+  return sealNoteKey(cfg.wrap, noteKey, kek, 'notekey');
 }
 
 export async function unwrapNoteKeyWithRecToken(cfg: NoteCryptoConfig, wrapped: string, recToken: string, identity: string): Promise<CryptoKey | null> {
   try {
-    if (!wrapped.startsWith(cfg.wrap)) return null;
+    if (!cfg.wrap) return null;
     const kek = await deriveRecKek(cfg, recToken, identity);
-    const rawHex = await decryptWithKey(kek, unb64(wrapped.slice(cfg.wrap.length)), 'notekey');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true); // 復原後要能重新包裹
+    return await openNoteKey(wrapped, kek, 'notekey', cfg.wrap);
   } catch {
     return null;
   }
 }
 
-/** 綁定請求的金鑰包裹三件套（bind 用）+ recovery_token_hash。 */
+/**
+ * 綁定請求的金鑰包裹三件套（bind 用）+ recovery_token_hash。
+ * 兩段 600k PBKDF2 相互獨立（pass 鹽隨機、rec 鹽=recSaltPrefix‖identity 定值）＝並行
+ *（t_7361b68c 目標 1：node 實測 133-152ms→68-84ms，與閘執行帳同源——round 2 MINOR-2 對齊）。
+ * AES-GCM derive 佔 600k 迴圈 99%，兩段 wrapped 各自隨機 iv（pass 段另隨機鹽 16B；rec 腿
+ * KEK 鹽定值、回傳 salt 來自 pass 腿 w1——round 2 MINOR-2 措辭修正）——逐位等值帳由
+ * 「兩段各自與 wrapNoteKey 直呼相等」承載。
+ */
 export async function buildBindPayload(
   cfg: NoteCryptoConfig,
   noteKey: CryptoKey,
@@ -378,11 +461,13 @@ export async function buildBindPayload(
   recToken: string,
   identity: string,
 ): Promise<{ wrapped: string; salt: string; wrappedRec: string; recTokenHash: string }> {
-  const { wrapped, salt } = await wrapNoteKey(cfg, noteKey, passphrase);
-  const wrappedRec = await wrapNoteKeyWithRecToken(cfg, noteKey, recToken, identity);
+  const [w1, wrappedRec] = await Promise.all([
+    wrapNoteKey(cfg, noteKey, passphrase),
+    wrapNoteKeyWithRecToken(cfg, noteKey, recToken, identity),
+  ]);
   return {
-    wrapped,
-    salt,
+    wrapped: w1.wrapped,
+    salt: w1.salt,
     wrappedRec,
     recTokenHash: await recTokenHash(recToken),
   };
@@ -392,20 +477,19 @@ export async function buildBindPayload(
 
 export async function storeLocalWrap(cfg: NoteCryptoConfig, identity: string, noteKey: CryptoKey): Promise<void> {
   try {
+    if (!cfg.wrap) throw new Error('ERR_WRAP_NOT_CONFIGURED');
     const guest = await deriveGuestKey(cfg, identity);
-    const raw = toHex(new Uint8Array(await crypto.subtle.exportKey('raw', noteKey)));
-    cfg.store.set(cfg.store.noteKeyWrap(identity), cfg.wrap + await encryptWithKey(guest, raw, 'notekey-local'));
+    const wrapped = await sealNoteKey(cfg.wrap, noteKey, guest, 'notekey-local');
+    cfg.store.set(cfg.store.noteKeyWrap(identity), wrapped);
   } catch { /* private mode：不阻擋主流程 */ }
 }
 
 async function loadLocalWrap(cfg: NoteCryptoConfig, identity: string): Promise<CryptoKey | null> {
   try {
     const stored = cfg.store.get(cfg.store.noteKeyWrap(identity));
-    if (!stored || !stored.startsWith(cfg.wrap)) return null;
+    if (!stored || !cfg.wrap) return null;
     const guest = await deriveGuestKey(cfg, identity);
-    const rawHex = await decryptWithKey(guest, unb64(stored.slice(cfg.wrap.length)), 'notekey-local');
-    if (!rawHex) return null;
-    return importAesGcm(hexToBytes(rawHex), true);
+    return await openNoteKey(stored, guest, 'notekey-local', cfg.wrap);
   } catch {
     return null;
   }
@@ -450,7 +534,11 @@ export async function encryptNote(
     return cfg.cipherBound + await encryptWithKey(held.get()!, plaintext, aad);
   }
   if (!cfg.cipherGuest) throw new Error('ERR_GUEST_NOT_CONFIGURED'); // guest 路徑選配：未配置即拒（bound 路徑不受牽連）
-  const guest = await deriveGuestKey(cfg, idp.current());
+  // 空 identity 拒絕（t_7710c766 目標 3）：K_u = SHA-256(prefix ‖ '') 仍可派生（sha256 不拋），
+  // 靜默產出「空帳號金鑰」＝可解同樣空 identity 的任何 guest 密文（對稱面誤配）。fail-closed。
+  const identity = idp.current();
+  if (!identity) throw new Error('ERR_NO_IDENTITY');
+  const guest = await deriveGuestKey(cfg, identity);
   return cfg.cipherGuest + await encryptWithKey(guest, plaintext, aad);
 }
 
@@ -464,7 +552,10 @@ export async function decryptNote(
   idp: IdentityProvider,
 ): Promise<string | null> {
   try {
-    const guestPrefix = cfg.cipherGuest;
+    // guest 前綴正規化（follow-up ②，t_44239f5f）：畸形配置 ''（空字串）會讓
+    // startsWith('') 恆真＝bound 列誤導 guest 分支回 null（解密面整列滅失）。
+    // falsy 一律收斂為 undefined，與加密面「未配置即拒」truthiness 對稱。
+    const guestPrefix = cfg.cipherGuest || undefined;
     const isGuest = guestPrefix !== undefined && cipher.startsWith(guestPrefix);
     const isBound = cipher.startsWith(cfg.cipherBound);
     if (!isGuest && !isBound) {
@@ -473,7 +564,11 @@ export async function decryptNote(
       return guestPrefix === undefined ? null : cipher;
     }
     if (isGuest) {
-      const guest = await deriveGuestKey(cfg, idp.current());
+      // 空 identity 拒絕（t_7710c766 目標 3，對稱面）：guest 密文在 identity 缺席時必 null
+      //（K_u 仍可派生但「空帳號金鑰」不是該密文作者的 intent；誤配下兩態皆 fail-closed）。
+      const identity = idp.current();
+      if (!identity) return null;
+      const guest = await deriveGuestKey(cfg, identity);
       return await decryptWithKey(guest, unb64(cipher.slice(guestPrefix!.length)), aad);
     }
     if (!held.get()) {

package/src/client/pinlock.ts

@@ -24,10 +24,12 @@ export const PINLOCK_ITERATIONS = 600_000;
 
 const SALT_LEN = 16;
 const IV_LEN = 12;
-/** pinSalt(16) + iv(12) + ct(hex(noteKey) 64B + GCM tag 16B) = 108B 固定。 */
+/** pinSalt(16) + iv(12) + ct(hex 字串 64B + GCM tag 16B) = 108B 固定。 */
 const PAYLOAD_LEN = SALT_LEN + IV_LEN + 80;
 
-/** 本機鎖定 cfg（各 fork config 注入；未配置 = API 拒絕，兄弟 fork 行為不變）。 */
+/** 本機鎖定 cfg（各 fork config 注入；未配置 = API 拒絕，兄弟 fork 行為不變）。
+ *  t_7710c766：noteKeyExtractable 必填死欄移除——解包輸出恆 extractable（鐵律 1，
+ *  要能再包裹／匯出）不是可調選項；tacet 消費端 TACET_PINLOCK 同步摘欄。 */
 export interface PinLockConfig {
   /** 本機鎖定包裹前綴，如 'jr1p.'. 未配置 = 拒絕。 */
   pinLock?: string;
@@ -35,8 +37,6 @@ export interface PinLockConfig {
   pinLockSaltPrefix?: string;
   /** AAD（鎖定包裹專用，與登入第二因子/分享包裹互斥）。未配置 = 拒絕。 */
   pinLockAad?: string;
-  /** 解包輸出的 noteKey（要能再包裹/匯出，鐵律 1）。 */
-  noteKeyExtractable: boolean;
 }
 
 /** KEK = PBKDF2-SHA256(pinNorm, pinLockSaltPrefix + hex(pinSalt), 600k) → AES-GCM key（nonextractable）。 */
@@ -63,7 +63,9 @@ async function deriveLockKek(pinNorm: string, pinSalt: Uint8Array, cfg: PinLockC
   );
 }
 
-/** jr1p. 包裹：payload = pinSalt[16] ‖ iv[12] ‖ GCM(KEK, hex(noteKey), aad)；全自描述（salt 內嵌）。 */
+/** jr1p. 包裹：payload = pinSalt[16] ‖ iv[12] ‖ GCM(KEK, hex(noteKey), aad)；全自描述（salt 內嵌）。
+ *  鹽內嵌家族（jr2w./jr3d./jr1p.）自帶三段組裝——sealNoteKey 是鹽外置家族形（iv‖ct），
+ *  內嵌鹽的 pinSalt 前綴不在其契約內（t_7710c766 毒化輪回歸實證：亂收口＝unwrap 恆 null）。 */
 export async function wrapNoteKeyPinLock(cfg: PinLockConfig, noteKey: CryptoKey, pin: string): Promise<string> {
   if (!cfg.pinLock || !cfg.pinLockSaltPrefix || !cfg.pinLockAad) throw new Error('ERR_PINLOCK_NOT_CONFIGURED');
   const pinNorm = normalizePin(pin);
@@ -84,7 +86,10 @@ export async function wrapNoteKeyPinLock(cfg: PinLockConfig, noteKey: CryptoKey,
   return cfg.pinLock + b64(payload);
 }
 
-/** jr1p. 解包：全自描述；任何不符（前綴/長度/PIN 空/AAD）回 null 不拋；成功 → noteKey extractable=true（鐵律 1）。 */
+/** jr1p. 解包：全自描述；任何不符（前綴/長度/PIN 空/AAD）回 null 不拋；成功 → noteKey extractable=true（鐵律 1）。
+ *  t_7710c766：嚴格檢查為鹽內嵌族自有（payload 嚴格 108B＋rawHex hex 形檢查；
+ *  hexToBytes fail-closed 由 try/catch 承接＝行為不變）——不經 openNoteKey 本體
+ *  （openNoteKey 是鹽外置家族 92B 形，pinSalt 前綴不在其契約內）。 */
 export async function unwrapNoteKeyPinLock(cfg: PinLockConfig, wrapped: string, pin: string): Promise<CryptoKey | null> {
   try {
     if (!cfg.pinLock || !cfg.pinLockSaltPrefix || !cfg.pinLockAad) return null;
@@ -92,12 +97,12 @@ export async function unwrapNoteKeyPinLock(cfg: PinLockConfig, wrapped: string,
     const payload = unb64(wrapped.slice(cfg.pinLock.length));
     if (payload.length !== PAYLOAD_LEN) return null;
     const pinSalt = payload.slice(0, SALT_LEN);
-    const ivPrefixedCt = payload.slice(SALT_LEN); // decryptWithKey 契約：payload = iv[12] ‖ ct
+    const ivPrefixedCt = payload.slice(SALT_LEN); // 鹽內嵌家族：payload = pinSalt[16] ‖ iv[12] ‖ ct
     const pinNorm = normalizePin(pin);
     if (!pinNorm) return null;
     const kek = await deriveLockKek(pinNorm, pinSalt, cfg);
     const rawHex = await decryptWithKey(kek, ivPrefixedCt, cfg.pinLockAad);
-    if (!rawHex) return null;
+    if (!rawHex || rawHex.length !== 64 || !/^[0-9a-f]+$/.test(rawHex)) return null;
     return importAesGcm(hexToBytes(rawHex), true);
   } catch {
     return null;

package/src/index.ts

@@ -19,6 +19,8 @@ export {
   wrapNoteKeyDual,
   unwrapNoteKeyDual,
   storeLocalWrap,
+  clearLocalWrap,
+  buildBindPayload,
   ph1Of,
   normalizePin,
   recTokenHash,
@@ -39,6 +41,7 @@ export {
   wrapNoteKeyShare3,
   unwrapNoteKeyShare3,
   derivePh1Argon,
+  PH1_V2_SALT,
   ARGON_MEMORY_KIB,
   ARGON_ITERATIONS,
   ARGON_PARALLELISM,