@shhhum/xftp-web 0.4.0 → 0.6.0

package/src/client.ts

@@ -16,7 +16,7 @@ import {
 import {verifyIdentityProof} from "./crypto/identity.js"
 import {generateX25519KeyPair, encodePubKeyX25519, dh} from "./crypto/keys.js"
 import {
-  encodeFNEW, encodeFADD, encodeFPUT, encodeFGET, encodeFACK, encodeFDEL, encodePING,
+  encodeFNEW, encodeFADD, encodeFPUT, encodeFGET, encodeFDEL, encodePING,
   decodeResponse, type FileResponse, type FileInfo, type XFTPErrorType
 } from "./protocol/commands.js"
 import {decryptReceivedChunk} from "./download.js"
@@ -172,33 +172,17 @@ interface ServerConnection {
   queue: Promise<void>          // tail of sequential command chain
 }
 
-export class XFTPAgent {
-  connections = new Map<string, ServerConnection>()
+export interface XFTPClientAgent {
+  connections: Map<string, ServerConnection>
   /** @internal Injectable for testing — defaults to connectXFTP */
   _connectFn: (server: XFTPServer) => Promise<XFTPClient>
+}
 
-  constructor(connectFn?: (server: XFTPServer) => Promise<XFTPClient>) {
-    this._connectFn = connectFn ?? connectXFTP
-  }
-
-  closeServer(server: XFTPServer): void {
-    const key = formatXFTPServer(server)
-    const conn = this.connections.get(key)
-    if (conn) {
-      this.connections.delete(key)
-      conn.client.then(c => c.transport.close(), () => {})
-    }
-  }
-
-  close(): void {
-    for (const conn of this.connections.values()) {
-      conn.client.then(c => c.transport.close(), () => {})
-    }
-    this.connections.clear()
-  }
+export function newXFTPAgent(): XFTPClientAgent {
+  return {connections: new Map(), _connectFn: connectXFTP}
 }
 
-export function getXFTPServerClient(agent: XFTPAgent, server: XFTPServer): Promise<XFTPClient> {
+export function getXFTPServerClient(agent: XFTPClientAgent, server: XFTPServer): Promise<XFTPClient> {
   const key = formatXFTPServer(server)
   let conn = agent.connections.get(key)
   if (!conn) {
@@ -213,7 +197,7 @@ export function getXFTPServerClient(agent: XFTPAgent, server: XFTPServer): Promi
   return conn.client
 }
 
-export function reconnectClient(agent: XFTPAgent, server: XFTPServer): Promise<XFTPClient> {
+export function reconnectClient(agent: XFTPClientAgent, server: XFTPServer): Promise<XFTPClient> {
   const key = formatXFTPServer(server)
   const old = agent.connections.get(key)
   old?.client.then(c => c.transport.close(), () => {})
@@ -228,7 +212,7 @@ export function reconnectClient(agent: XFTPAgent, server: XFTPServer): Promise<X
 }
 
 export function removeStaleConnection(
-  agent: XFTPAgent, server: XFTPServer, failedP: Promise<XFTPClient>
+  agent: XFTPClientAgent, server: XFTPServer, failedP: Promise<XFTPClient>
 ): void {
   const key = formatXFTPServer(server)
   const conn = agent.connections.get(key)
@@ -238,9 +222,25 @@ export function removeStaleConnection(
   }
 }
 
+export function closeXFTPServerClient(agent: XFTPClientAgent, server: XFTPServer): void {
+  const key = formatXFTPServer(server)
+  const conn = agent.connections.get(key)
+  if (conn) {
+    agent.connections.delete(key)
+    conn.client.then(c => c.transport.close(), () => {})
+  }
+}
+
+export function closeXFTPAgent(agent: XFTPClientAgent): void {
+  for (const conn of agent.connections.values()) {
+    conn.client.then(c => c.transport.close(), () => {})
+  }
+  agent.connections.clear()
+}
+
 // -- Connect + handshake
 
-export async function connectXFTP(server: XFTPServer, config?: Partial<TransportConfig>): Promise<XFTPClient> {
+async function connectXFTP(server: XFTPServer, config?: Partial<TransportConfig>): Promise<XFTPClient> {
   const cfg: TransportConfig = {...DEFAULT_TRANSPORT_CONFIG, ...config}
   const baseUrl = "https://" + server.host + ":" + server.port
   const transport = await createTransport(baseUrl, cfg)
@@ -342,7 +342,7 @@ function _hex(b: Uint8Array, n = 8): string {
 // -- Send command (with retry + reconnect)
 
 export async function sendXFTPCommand(
-  agent: XFTPAgent,
+  agent: XFTPClientAgent,
   server: XFTPServer,
   privateKey: Uint8Array,
   entityId: Uint8Array,
@@ -375,7 +375,7 @@ export async function sendXFTPCommand(
 // -- Command wrappers
 
 export async function createXFTPChunk(
-  agent: XFTPAgent, server: XFTPServer, spKey: Uint8Array, file: FileInfo,
+  agent: XFTPClientAgent, server: XFTPServer, spKey: Uint8Array, file: FileInfo,
   rcvKeys: Uint8Array[], auth: Uint8Array | null = null
 ): Promise<{senderId: Uint8Array, recipientIds: Uint8Array[]}> {
   const {response} = await sendXFTPCommand(agent, server, spKey, new Uint8Array(0), encodeFNEW(file, rcvKeys, auth))
@@ -384,7 +384,7 @@ export async function createXFTPChunk(
 }
 
 export async function addXFTPRecipients(
-  agent: XFTPAgent, server: XFTPServer, spKey: Uint8Array, fId: Uint8Array, rcvKeys: Uint8Array[]
+  agent: XFTPClientAgent, server: XFTPServer, spKey: Uint8Array, fId: Uint8Array, rcvKeys: Uint8Array[]
 ): Promise<Uint8Array[]> {
   const {response} = await sendXFTPCommand(agent, server, spKey, fId, encodeFADD(rcvKeys))
   if (response.type !== "FRRcvIds") throw new Error("unexpected response: " + response.type)
@@ -392,7 +392,7 @@ export async function addXFTPRecipients(
 }
 
 export async function uploadXFTPChunk(
-  agent: XFTPAgent, server: XFTPServer, spKey: Uint8Array, fId: Uint8Array, chunkData: Uint8Array
+  agent: XFTPClientAgent, server: XFTPServer, spKey: Uint8Array, fId: Uint8Array, chunkData: Uint8Array
 ): Promise<void> {
   const {response} = await sendXFTPCommand(agent, server, spKey, fId, encodeFPUT(), chunkData)
   if (response.type !== "FROk") throw new Error("unexpected response: " + response.type)
@@ -405,7 +405,7 @@ export interface RawChunkResponse {
 }
 
 export async function downloadXFTPChunkRaw(
-  agent: XFTPAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array
+  agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array
 ): Promise<RawChunkResponse> {
   const {publicKey, privateKey} = generateX25519KeyPair()
   const cmd = encodeFGET(encodePubKeyX25519(publicKey))
@@ -417,27 +417,20 @@ export async function downloadXFTPChunkRaw(
 }
 
 export async function downloadXFTPChunk(
-  agent: XFTPAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array, digest?: Uint8Array
+  agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array, digest?: Uint8Array
 ): Promise<Uint8Array> {
   const {dhSecret, nonce, body} = await downloadXFTPChunkRaw(agent, server, rpKey, fId)
   return decryptReceivedChunk(dhSecret, nonce, body, digest ?? null)
 }
 
 export async function deleteXFTPChunk(
-  agent: XFTPAgent, server: XFTPServer, spKey: Uint8Array, sId: Uint8Array
+  agent: XFTPClientAgent, server: XFTPServer, spKey: Uint8Array, sId: Uint8Array
 ): Promise<void> {
   const {response} = await sendXFTPCommand(agent, server, spKey, sId, encodeFDEL())
   if (response.type !== "FROk") throw new Error("unexpected response: " + response.type)
 }
 
-export async function ackXFTPChunk(
-  agent: XFTPAgent, server: XFTPServer, rpKey: Uint8Array, rId: Uint8Array
-): Promise<void> {
-  const {response} = await sendXFTPCommand(agent, server, rpKey, rId, encodeFACK())
-  if (response.type !== "FROk") throw new Error("unexpected response: " + response.type)
-}
-
-export async function pingXFTP(agent: XFTPAgent, server: XFTPServer): Promise<void> {
+export async function pingXFTP(agent: XFTPClientAgent, server: XFTPServer): Promise<void> {
   const client = await getXFTPServerClient(agent, server)
   const corrId = new Uint8Array(0)
   const block = encodeTransmission(client.sessionId, corrId, new Uint8Array(0), encodePING())

package/src/crypto/digest.ts

@@ -1,6 +1,6 @@
 // Cryptographic hash functions matching Simplex.Messaging.Crypto (sha256Hash, sha512Hash).
 
-import sodium, {type StateAddress} from "libsodium-wrappers-sumo"
+import sodium from "libsodium-wrappers-sumo"
 
 // SHA-256 digest (32 bytes) -- Crypto.hs:1006
 export function sha256(data: Uint8Array): Uint8Array {
@@ -12,24 +12,11 @@ export function sha512(data: Uint8Array): Uint8Array {
   return sodium.crypto_hash_sha512(data)
 }
 
-// Incremental SHA-512 — for computing digest during streaming encryption.
-export function sha512Init(): StateAddress {
-  return sodium.crypto_hash_sha512_init() as unknown as StateAddress
-}
-
-export function sha512Update(state: StateAddress, data: Uint8Array): void {
-  sodium.crypto_hash_sha512_update(state, data)
-}
-
-export function sha512Final(state: StateAddress): Uint8Array {
-  return sodium.crypto_hash_sha512_final(state)
-}
-
 // Streaming SHA-512 over multiple chunks -- avoids copying large data into WASM memory at once.
 // Internally segments chunks larger than 4MB to limit peak WASM memory usage.
 export function sha512Streaming(chunks: Iterable<Uint8Array>): Uint8Array {
   const SEG = 4 * 1024 * 1024
-  const state = sodium.crypto_hash_sha512_init() as unknown as StateAddress
+  const state = sodium.crypto_hash_sha512_init() as unknown as sodium.StateAddress
   for (const chunk of chunks) {
     for (let off = 0; off < chunk.length; off += SEG) {
       sodium.crypto_hash_sha512_update(state, chunk.subarray(off, Math.min(off + SEG, chunk.length)))

package/src/crypto/file.ts

@@ -3,7 +3,6 @@
 
 import {Decoder, concatBytes, encodeInt64, encodeString, decodeString, encodeMaybe, decodeMaybe} from "../protocol/encoding.js"
 import {sbInit, sbEncryptChunk, sbDecryptTailTag, sbAuth} from "./secretbox.js"
-import {prepareChunkSizes, fileSizeLen, authTagSize} from "../protocol/chunks.js"
 
 const AUTH_TAG_SIZE = 16n
 
@@ -70,88 +69,6 @@ export function encryptFile(
   return concatBytes(hdr, encSource, encPad, tag)
 }
 
-// Async variant: encrypts source in 64KB slices, yielding between each to avoid blocking the main thread.
-// Produces identical output to encryptFile.
-// When onSlice is provided, encrypted data is streamed to the callback instead of buffered.
-const ENCRYPT_SLICE = 65536
-
-export async function encryptFileAsync(
-  source: Uint8Array, fileHdr: Uint8Array,
-  key: Uint8Array, nonce: Uint8Array,
-  fileSize: bigint, encSize: bigint,
-  onProgress?: (done: number, total: number) => void
-): Promise<Uint8Array>
-export async function encryptFileAsync(
-  source: Uint8Array, fileHdr: Uint8Array,
-  key: Uint8Array, nonce: Uint8Array,
-  fileSize: bigint, encSize: bigint,
-  onProgress: ((done: number, total: number) => void) | undefined,
-  onSlice: (data: Uint8Array) => void | Promise<void>
-): Promise<void>
-export async function encryptFileAsync(
-  source: Uint8Array,
-  fileHdr: Uint8Array,
-  key: Uint8Array,
-  nonce: Uint8Array,
-  fileSize: bigint,
-  encSize: bigint,
-  onProgress?: (done: number, total: number) => void,
-  onSlice?: (data: Uint8Array) => void | Promise<void>
-): Promise<Uint8Array | void> {
-  const state = sbInit(key, nonce)
-  const lenStr = encodeInt64(fileSize)
-  const padLen = Number(encSize - AUTH_TAG_SIZE - fileSize - 8n)
-  if (padLen < 0) throw new Error("encryptFile: encSize too small")
-  const out = onSlice ? null : new Uint8Array(Number(encSize))
-  let outOff = 0
-
-  async function emit(data: Uint8Array) {
-    if (onSlice) {
-      await onSlice(data)
-    } else {
-      out!.set(data, outOff)
-      outOff += data.length
-    }
-  }
-
-  await emit(sbEncryptChunk(state, concatBytes(lenStr, fileHdr)))
-  for (let off = 0; off < source.length; off += ENCRYPT_SLICE) {
-    const end = Math.min(off + ENCRYPT_SLICE, source.length)
-    await emit(sbEncryptChunk(state, source.subarray(off, end)))
-    onProgress?.(end, source.length)
-    await new Promise<void>(r => setTimeout(r, 0))
-  }
-  const padding = new Uint8Array(padLen)
-  padding.fill(0x23)
-  await emit(sbEncryptChunk(state, padding))
-  await emit(sbAuth(state))
-  if (out) return out
-}
-
-// -- Encryption preparation (key gen + chunk sizing)
-
-export interface EncryptionParams {
-  fileHdr: Uint8Array
-  key: Uint8Array
-  nonce: Uint8Array
-  fileSize: bigint
-  encSize: bigint
-  chunkSizes: number[]
-}
-
-export function prepareEncryption(sourceSize: number, fileName: string): EncryptionParams {
-  const key = new Uint8Array(32)
-  const nonce = new Uint8Array(24)
-  crypto.getRandomValues(key)
-  crypto.getRandomValues(nonce)
-  const fileHdr = encodeFileHeader({fileName, fileExtra: null})
-  const fileSize = BigInt(fileHdr.length + sourceSize)
-  const payloadSize = Number(fileSize) + fileSizeLen + authTagSize
-  const chunkSizes = prepareChunkSizes(payloadSize)
-  const encSize = BigInt(chunkSizes.reduce((a, b) => a + b, 0))
-  return {fileHdr, key, nonce, fileSize, encSize, chunkSizes}
-}
-
 // -- Decryption (FileTransfer.Crypto:decryptChunks)
 
 // Decrypt one or more XFTP chunks into a FileHeader and file content.

package/src/protocol/commands.ts

@@ -22,18 +22,11 @@ export interface FileInfo {
 
 export type CommandError = "UNKNOWN" | "SYNTAX" | "PROHIBITED" | "NO_AUTH" | "HAS_AUTH" | "NO_ENTITY"
 
-export type BlockingReason = "spam" | "content"
-
-export interface BlockingInfo {
-  reason: BlockingReason
-  notice: {ttl: number | null} | null
-}
-
 export type XFTPErrorType =
   | {type: "BLOCK"} | {type: "SESSION"} | {type: "HANDSHAKE"}
   | {type: "CMD", cmdErr: CommandError}
   | {type: "AUTH"}
-  | {type: "BLOCKED", blockInfo: BlockingInfo}
+  | {type: "BLOCKED", blockInfo: string}
   | {type: "SIZE"} | {type: "QUOTA"} | {type: "DIGEST"} | {type: "CRYPTO"}
   | {type: "NO_FILE"} | {type: "HAS_FILE"} | {type: "FILE_IO"}
   | {type: "TIMEOUT"} | {type: "INTERNAL"}
@@ -80,8 +73,6 @@ export function encodeFPUT(): Uint8Array { return ascii("FPUT") }
 
 export function encodeFDEL(): Uint8Array { return ascii("FDEL") }
 
-export function encodeFACK(): Uint8Array { return ascii("FACK") }
-
 export function encodeFGET(rcvDhKey: Uint8Array): Uint8Array {
   return concatBytes(ascii("FGET"), SPACE, encodeBytes(rcvDhKey))
 }
@@ -111,17 +102,6 @@ function decodeCommandError(s: string): CommandError {
   throw new Error("bad CommandError: " + s)
 }
 
-function decodeBlockingInfo(s: string): BlockingInfo {
-  const noticeIdx = s.indexOf(",notice=")
-  const reasonPart = noticeIdx >= 0 ? s.slice(0, noticeIdx) : s
-  const reason: BlockingReason = reasonPart === "reason=spam" ? "spam" : "content"
-  let notice: {ttl: number | null} | null = null
-  if (noticeIdx >= 0) {
-    try { notice = JSON.parse(s.slice(noticeIdx + 8)) } catch {}
-  }
-  return {reason, notice}
-}
-
 export function decodeXFTPError(d: Decoder): XFTPErrorType {
   const s = readTag(d)
   switch (s) {
@@ -135,7 +115,7 @@ export function decodeXFTPError(d: Decoder): XFTPErrorType {
       const rest = d.takeAll()
       let info = ""
       for (let i = 0; i < rest.length; i++) info += String.fromCharCode(rest[i])
-      return {type: "BLOCKED", blockInfo: decodeBlockingInfo(info)}
+      return {type: "BLOCKED", blockInfo: info}
     }
     case "SIZE": return {type: "SIZE"}
     case "QUOTA": return {type: "QUOTA"}

package/web/crypto-backend.ts

@@ -0,0 +1,140 @@
+import type {FileHeader} from '../src/crypto/file.js'
+
+export interface CryptoBackend {
+  encrypt(data: Uint8Array, fileName: string,
+          onProgress?: (done: number, total: number) => void
+  ): Promise<EncryptResult>
+  readChunk(offset: number, size: number): Promise<Uint8Array>
+  decryptAndStoreChunk(
+    dhSecret: Uint8Array, nonce: Uint8Array,
+    body: Uint8Array, digest: Uint8Array, chunkNo: number
+  ): Promise<void>
+  verifyAndDecrypt(params: {size: number, digest: Uint8Array, key: Uint8Array, nonce: Uint8Array}
+  ): Promise<{header: FileHeader, content: Uint8Array}>
+  cleanup(): Promise<void>
+}
+
+export interface EncryptResult {
+  digest: Uint8Array
+  key: Uint8Array
+  nonce: Uint8Array
+  chunkSizes: number[]
+}
+
+type PendingRequest = {resolve: (value: any) => void, reject: (reason: any) => void}
+
+class WorkerBackend implements CryptoBackend {
+  private worker: Worker
+  private pending = new Map<number, PendingRequest>()
+  private nextId = 1
+  private progressCb: ((done: number, total: number) => void) | null = null
+  private ready: Promise<void>
+
+  constructor() {
+    this.worker = new Worker(new URL('./crypto.worker.ts', import.meta.url), {type: 'module'})
+    let rejectReady: (e: Error) => void
+    this.ready = new Promise((resolve, reject) => {
+      rejectReady = reject
+      this.worker.onmessage = (e) => {
+        if (e.data?.type === 'ready') {
+          this.worker.onmessage = (e) => this.handleMessage(e.data)
+          resolve()
+        } else {
+          reject(new Error('Worker: unexpected first message'))
+        }
+      }
+    })
+    this.worker.onerror = (e) => {
+      rejectReady(new Error('Worker failed to load: ' + e.message))
+      for (const p of this.pending.values()) p.reject(new Error('Worker error: ' + e.message))
+      this.pending.clear()
+    }
+  }
+
+  private handleMessage(msg: {id: number, type: string, [k: string]: any}) {
+    if (msg.type === 'progress') {
+      this.progressCb?.(msg.done, msg.total)
+      return
+    }
+    const p = this.pending.get(msg.id)
+    if (!p) return
+    this.pending.delete(msg.id)
+    if (msg.type === 'error') {
+      p.reject(new Error(msg.message))
+    } else {
+      p.resolve(msg)
+    }
+  }
+
+  private async send(msg: Record<string, any>, transfer?: Transferable[]): Promise<any> {
+    await this.ready
+    const id = this.nextId++
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {resolve, reject})
+      this.worker.postMessage({...msg, id}, transfer ?? [])
+    })
+  }
+
+  private toTransferable(data: Uint8Array): ArrayBuffer {
+    if (data.byteOffset !== 0 || data.byteLength !== data.buffer.byteLength) {
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) as ArrayBuffer
+    }
+    return data.buffer as ArrayBuffer
+  }
+
+  async encrypt(data: Uint8Array, fileName: string,
+                onProgress?: (done: number, total: number) => void): Promise<EncryptResult> {
+    this.progressCb = onProgress ?? null
+    const buf = this.toTransferable(data)
+    const resp = await this.send({type: 'encrypt', data: buf, fileName}, [buf])
+    this.progressCb = null
+    return {digest: resp.digest, key: resp.key, nonce: resp.nonce, chunkSizes: resp.chunkSizes}
+  }
+
+  async readChunk(offset: number, size: number): Promise<Uint8Array> {
+    const resp = await this.send({type: 'readChunk', offset, size})
+    return new Uint8Array(resp.data)
+  }
+
+  async decryptAndStoreChunk(
+    dhSecret: Uint8Array, nonce: Uint8Array,
+    body: Uint8Array, digest: Uint8Array, chunkNo: number
+  ): Promise<void> {
+    // Copy arrays to ensure clean ArrayBuffer separation before worker transfer
+    // nonce/dhSecret may be subarrays sharing buffer with body
+    const dhSecretCopy = new Uint8Array(dhSecret)
+    const nonceCopy = new Uint8Array(nonce)
+    const digestCopy = new Uint8Array(digest)
+    const buf = this.toTransferable(body)
+    const hex = (b: Uint8Array | ArrayBuffer, n = 8) => {
+      const u = b instanceof ArrayBuffer ? new Uint8Array(b) : b
+      return Array.from(u.slice(0, n)).map(x => x.toString(16).padStart(2, '0')).join('')
+    }
+    console.log(`[BACKEND-DBG] chunk=${chunkNo} body.len=${body.length} body.byteOff=${body.byteOffset} buf.byteLen=${buf.byteLength} nonce=${hex(nonceCopy, 24)} dhSecret=${hex(dhSecretCopy)} digest=${hex(digestCopy, 32)} buf[0..8]=${hex(buf)} body[-8..]=${hex(body.slice(-8))}`)
+    await this.send(
+      {type: 'decryptAndStoreChunk', dhSecret: dhSecretCopy, nonce: nonceCopy, body: buf, chunkDigest: digestCopy, chunkNo},
+      [buf]
+    )
+  }
+
+  async verifyAndDecrypt(params: {size: number, digest: Uint8Array, key: Uint8Array, nonce: Uint8Array}
+  ): Promise<{header: FileHeader, content: Uint8Array}> {
+    const resp = await this.send({
+      type: 'verifyAndDecrypt',
+      size: params.size, digest: params.digest, key: params.key, nonce: params.nonce
+    })
+    return {header: resp.header, content: new Uint8Array(resp.content)}
+  }
+
+  async cleanup(): Promise<void> {
+    await this.send({type: 'cleanup'})
+    this.worker.terminate()
+  }
+}
+
+export function createCryptoBackend(): CryptoBackend {
+  if (typeof Worker === 'undefined') {
+    throw new Error('Web Workers required — update your browser')
+  }
+  return new WorkerBackend()
+}