feat(mnp)!: seal the upload under the group key

Downloads have been encrypted under a GEK-derived key since the beginning:
`file_chunk` and `stream_data` both go through `chunk_ciphertext`. Uploads
never were. `file_upload` carried the filename and the raw bytes in plain
msgpack, and `file_upload_ack` carried the name the node stored them under —
so the same file was ciphertext leaving a node and plaintext arriving at one.
There was no threat model behind that asymmetry.

Both halves now travel sealed under a third groupbox purpose,
HKDF(GEK, info="meshbay:upload:v1"). The filename, the destination folder and
the bytes are all inside the seal; only `upload_id` and `chunk_index` stay in
clear, because the node routes and orders on them before it can decrypt. This
direction seals *towards* the node — it holds the GEK for its own group — and
it opens the payload before it picks a destination or touches the disk.

What that forced, and why none of it is optional:

  - `filename` was the correlation key on both sides. It cannot be: matching an
    ack to its request by name would hand back exactly what the seal hides.
    `upload_id` replaces it — client-drawn, opaque to the node, unique within a
    connection, never an authorization input. The property it guarded (one
    refusal fails one upload, not every upload in flight) is unchanged.
  - Refusals can no longer quote what they refused. `No directory named 'X'`
    becomes `No such directory in this group` plus the `code` that was already
    there; the client knows what it sent.
  - No plaintext fallback. A path that still accepts plaintext is not a sealed
    path, so an unsealed `file_upload` is refused with `upload_not_sealed`.

Hardened while here, because what comes out of a seal is authenticated but not
validated — a member can seal anything: `filename` and `data` have their types
checked before any upload state is created, and `chunk_index`/`total_chunks`,
which are outside the seal by necessity, can no longer raise where a refusal
was meant.

Tests. `test_upload_sealed.py` pins the node half: nothing identifying on the
wire, tamper/wrong-key/wrong-group all refused with nothing written, and
multi-chunk reassembly unchanged. `test_upload_seal_client.py` drives the
shipped `uploadFile` over the shipped `crypto.js` under node and feeds its real
frames to the real `_do_file_upload` — the file lands intact, and the ack the
node actually produced comes back with the name it chose for a collision, which
is the half a source-reading test cannot see. Both upload purposes join the
JS/Python groupbox parity vectors.

BREAKING CHANGE: MNP 2.0. `file_upload`/`file_upload_ack` change shape on the
wire every deployed client speaks, which is MAJOR by the same rule 1.0 was —
but the break is confined to uploads. `MNP_MIN_SUPPORTED` stays at "1.0", so a
1.x peer still connects, browses, downloads, streams and chats; only its
uploads are refused, with a message saying which side is old. The client checks
the node's version before sending a chunk, so neither side meets this as a
timeout. This is the version negotiation shipped in 1.0 earning its keep: 1.0
cost a flag day, 2.0 costs a refusal code.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AsoWC3GmhNdwVFomW3QjH3

2 files changed, 92 insertions, 29 deletions

diff --git a/packages/meshbay-hub/src/meshbay_hub/static/crypto.js b/packages/meshbay-hub/src/meshbay_hub/static/crypto.js
index d2e19b7..4d26c6d 100644
--- a/packages/meshbay-hub/src/meshbay_hub/static/crypto.js
+++ b/packages/meshbay-hub/src/meshbay_hub/static/crypto.js
@@ -111,8 +111,9 @@ async function decryptChunkBin(gek, fileHashHex, chunkIndex, nonce, ct) {
 
 // ── Sealing a payload under the group key ────────────────────────────────────
 //
-// Mirrors meshbay_common/groupbox.py. `index_sync`, `index_delta` and the
-// `handshake_ack` config payload travel sealed under a GEK-derived subkey; the
+// Mirrors meshbay_common/groupbox.py. `index_sync`, `index_delta`, the
+// `handshake_ack` config payload and both halves of an upload travel sealed
+// under a GEK-derived subkey; the
 // routing fields (type, v, group_id) and the ack's own authentication (node_pk,
 // proof, sig) stay in clear, because a receiver must route, version-check and
 // *authenticate* before it would trust a decryption.
@@ -126,6 +127,11 @@ async function decryptChunkBin(gek, fileHashHex, chunkIndex, nonce, ct) {
 const GROUPBOX_INFO = {
   index: new TextEncoder().encode('meshbay:index:v1'),
   ack: new TextEncoder().encode('meshbay:ack:v1'),
+  // MNP 2.0: `file_upload` and `file_upload_ack`. This is the one purpose that
+  // seals *towards* the node — it holds the GEK for its own group — and the one
+  // with real message volume, one per 48 KB chunk. groupbox.py carries the
+  // nonce-collision arithmetic that makes a random 96-bit nonce fine at that rate.
+  upload: new TextEncoder().encode('meshbay:upload:v1'),
 };
 
 /**
diff --git a/packages/meshbay-hub/src/meshbay_hub/static/transport.js b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
index 2668e02..681a9ba 100644
--- a/packages/meshbay-hub/src/meshbay_hub/static/transport.js
+++ b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
@@ -248,7 +248,7 @@ window.addEventListener('hashchange', () => {
 // The `v: '0.1'` on every other message in this file is the historical value
 // and is read by nothing; it is left alone deliberately. The range is
 // negotiated once, at the start, not restated per message.
-const MNP_V = '1.1';
+const MNP_V = '2.0';
 const MNP_V_MIN = '1.0';
 
 // Codes a NODE sends us, in its own vocabulary (meshbay_common/handshake.py's
@@ -301,10 +301,17 @@ class MeshBayTransport {
     this._onStreamEnd = null;
     this._onStreamError = null;
     this._onIndexSync = null;
-    // filename → the uploader waiting on it. Keyed rather than FIFO because
-    // several uploads may be in flight at once and their acks interleave; the
-    // node names the file in every one.
+    // upload_id → the uploader waiting on it. Keyed rather than FIFO because
+    // several uploads may be in flight at once and their acks interleave.
+    //
+    // It was keyed by filename until MNP 2.0, which is no longer possible: the
+    // name is sealed under the group key, and echoing it in clear so the two
+    // sides could match on it would give back precisely what the seal is for.
+    // `upload_id` is drawn per upload here and is opaque to the node.
     this._uploaders = new Map();
+    // Names, not ids: the "already being uploaded" guard is about the file the
+    // caller passed, and two `uploadFile` calls for one file draw two ids.
+    this._inFlightUploads = new Set();
     // Set once close() runs — stops the automatic reconnect from firing on a
     // connection the caller tore down on purpose (leaving the group, page
     // unload), which would otherwise race back in right as everything else
@@ -381,6 +388,19 @@ class MeshBayTransport {
     if (!m) return false;
     return (Number(m[1]) > 1) || (Number(m[1]) === 1 && Number(m[2]) >= 1);
   }
+  /**
+   * Whether the node opens a sealed upload (MNP 2.0).
+   *
+   * A 1.x node reads `filename` and `data` off the message itself, finds
+   * neither — they are inside the seal — and answers "Missing filename or
+   * data", an error about the wrong thing that names no upload_id and so fails
+   * every upload in flight. Asked before sending rather than discovered after,
+   * for the same reason `supportsAppOps` is.
+   */
+  get supportsSealedUpload() {
+    const m = /^(\d+)\.(\d+)$/.exec(this._nodeVersion || '');
+    return !!m && Number(m[1]) >= 2;
+  }
   set onAppsEnabled(fn) { this._onAppsEnabled = fn; }
   set onAppDirectories(fn) { this._onAppDirectories = fn; }
   set onChatDirectory(fn) { this._onChatDirectory = fn; }
@@ -1812,10 +1832,21 @@ class MeshBayTransport {
    */
   async uploadFile(file, { chunkSize, onProgress, signal, root, dir } = {}) {
     // The same file twice at once would confuse the node, which keys its own
-    // upload state by name — and would race for the same destination.
-    if (this._uploaders.has(file.name)) {
+    // upload state by name — and would race for the same destination. The guard
+    // is by name for that reason, even though the map below is keyed by id.
+    if (this._inFlightUploads.has(file.name)) {
       throw new Error(`${file.name} is already being uploaded`);
     }
+    if (!this._gekRaw) throw new Error('This group has no key on this device');
+    if (!this.supportsSealedUpload) {
+      throw new Error(
+        'This node is running an older MeshBay and cannot accept an upload '
+        + 'from this page. Its operator has to update it.');
+    }
+    const C = window.MeshBayCrypto;
+    const groupId = (this._connectArgs && this._connectArgs.groupId) || '';
+    this._inFlightUploads.add(file.name);
+    const uploadId = _hex(crypto.getRandomValues(new Uint8Array(16)));
     const size = chunkSize || UPLOAD_CHUNK_SIZE;
     const total = Math.max(1, Math.ceil(file.size / size));
     let acked = 0;
@@ -1823,16 +1854,32 @@ class MeshBayTransport {
     let failure = null;
 
     const acks = [];
-    this._uploaders.set(file.name, (msg) => {
-      if (msg.type === 'error') {
-        failure = new Error(msg.detail || 'Upload refused');
-      } else if (msg.stored_as) {
-        stored = msg;
-      }
+    const wake = () => {
       acked += 1;
       if (onProgress) onProgress(Math.min(file.size, acked * size), file.size);
       const waiter = acks.shift();
       if (waiter) waiter();
+    };
+    this._uploaders.set(uploadId, (msg) => {
+      if (msg.type === 'error') {
+        failure = new Error(msg.detail || 'Upload refused');
+        wake();
+        return;
+      }
+      // The ack is sealed too — `stored_as` and the folder it landed in name
+      // the operator's content. Opening it is what makes the result usable, so
+      // a failure here fails the upload rather than being swallowed: a chat
+      // attachment that cannot learn its stored name would point at nothing.
+      C.openGroup(this._gekRaw, 'upload', 'file_upload_ack', groupId, msg)
+        .then((plain) => {
+          const payload = msgpack_decode(plain);
+          if (payload.stored_as) stored = payload;
+        })
+        .catch((e) => {
+          failure = new Error(
+            `The node's upload reply did not open under the group key (${e.message})`);
+        })
+        .finally(wake);
     });
 
     const nextAck = () => new Promise(r => acks.push(r));
@@ -1854,15 +1901,20 @@ class MeshBayTransport {
 
         const buf = new Uint8Array(
           await file.slice(i * size, (i + 1) * size).arrayBuffer());
+        // The name, the destination and the bytes go inside the seal together.
+        // Mirrors `file_upload_wire` in meshbay_common/protocol.py; only the
+        // fields the node routes on stay outside it.
+        const sealed = await C.sealGroup(
+          this._gekRaw, 'upload', 'file_upload', groupId,
+          msgpack_encode({ filename: file.name, data: buf,
+                           dir: dir || '', root: root || '' }));
         this._send({
           type: 'file_upload',
           v: '0.1',
-          filename: file.name,
+          upload_id: uploadId,
           chunk_index: i,
           total_chunks: total,
-          data: buf,
-          ...(root ? { root } : {}),
-          ...(dir ? { dir } : {}),
+          ...sealed,
         });
       }
       while (acked < total) {
@@ -1870,7 +1922,8 @@ class MeshBayTransport {
         if (failure) throw failure;
       }
     } finally {
-      this._uploaders.delete(file.name);
+      this._uploaders.delete(uploadId);
+      this._inFlightUploads.delete(file.name);
     }
     return stored || {};
   }
@@ -2427,21 +2480,21 @@ class MeshBayTransport {
     // While an upload is in flight the acks are its own, and there are many of
     // them: they must not be handed to whatever request happens to be oldest in
     // the pending map.
-    if (msg.type === 'file_upload_ack' && this._uploaders.has(msg.filename)) {
-      this._uploaders.get(msg.filename)(msg);
+    if (msg.type === 'file_upload_ack' && this._uploaders.has(msg.upload_id)) {
+      this._uploaders.get(msg.upload_id)(msg);
       return;
     }
-    // An upload refusal names the file it is about, so only that upload fails.
-    // It did not use to, and there was no way to tell whose error it was, so
-    // every upload in flight was failed together — send a second file whose
-    // name the node dislikes and both died. The broadcast is kept for a node
-    // that does not name it, where guessing wrong is worse than stopping.
+    // An upload refusal names the upload it is about, so only that upload
+    // fails. It did not use to, and there was no way to tell whose error it
+    // was, so every upload in flight was failed together — send a second file
+    // whose name the node dislikes and both died. The broadcast is kept for a
+    // refusal that names none, where guessing wrong is worse than stopping.
     if (msg.type === 'error' && this._uploaders.size) {
-      if (msg.filename && this._uploaders.has(msg.filename)) {
-        this._uploaders.get(msg.filename)(msg);
+      if (msg.upload_id && this._uploaders.has(msg.upload_id)) {
+        this._uploaders.get(msg.upload_id)(msg);
         return;
       }
-      if (!msg.filename) {
+      if (!msg.upload_id) {
         for (const handler of [...this._uploaders.values()]) handler(msg);
         return;
       }
@@ -3017,6 +3070,10 @@ function _decodeMap(buf, view, offset, count) {
   return [obj, offset];
 }
 
+function _hex(bytes) {
+  return [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
 function _extractDtlsFingerprint(sdp) {
   const match = sdp.match(/a=fingerprint:sha-256 ([0-9A-Fa-f:]+)/);
   if (!match) return new Uint8Array(0);