xftp-web: show errors as text, limit downloads to description sizes (#2072)

* tests: show xftp-web errors as text, limit chunks to description sizes

* tests: download chunks of one server in sequence in xftp-web

* xftp-web: show error messages as text

* xftp-web: define size units in the chunks module

* xftp-web: limit downloaded chunks to the sizes in file descriptions

* ci: type-check xftp-web pages

* xftp-web: download chunks of one server in one sequence

* tests: import Data.ByteString.Char8 as BC in xftp-web tests

* xftp-web: show the empty file message as text

* ci: revert xftp-web page type-check

* tests: require chunks in xftp-web file descriptions

* xftp-web: require chunks in file descriptions
This commit is contained in:
Evgeny @ SimpleX Chat authored and GitHub committed 2026-11-14 23:19:22 +00:00
1 parent fdbcb24d86
commit 45eaff09c0
9 files changed
+177 -37

No files matched your search

@@ -625,12 +625,15 @@ function parseReplicaField(entry, lines, nextIdx, group) {
return nextIdx;
}
function validateFileDescription(fd) {
if (fd.chunks.length === 0) return "no chunks";
for (let i = 0; i < fd.chunks.length; i++) {
if (fd.chunks[i].chunkNo !== i + 1) return "chunk numbers are not sequential";
}
let total = 0;
for (const c of fd.chunks) total += c.chunkSize;
if (total !== fd.size) return "chunks total size is different than file size";
if (fd.chunks.some((c) => !serverChunkSizes.includes(c.chunkSize))) return "incorrect chunk size";
if (fd.redirect !== null && fd.size > chunkSize3) return "redirect file description is too large";
return null;
}
@@ -10279,6 +10282,7 @@ const chunkSize0 = kb(64);
const chunkSize1 = kb(256);
const chunkSize2 = mb(1);
const chunkSize3 = mb(4);
const serverChunkSizes = [chunkSize0, chunkSize1, chunkSize2, chunkSize3];
const fileSizeLen = 8;
const authTagSize = 16;
function size34(sz) {
@@ -10961,16 +10965,17 @@ async function uploadXFTPChunk(agent, server, spKey, fId, chunkData) {
const { response } = await sendXFTPCommand(agent, server, spKey, fId, encodeFPUT(), chunkData);
if (response.type !== "FROk") throw new Error("unexpected response: " + response.type);
}
async function downloadXFTPChunkRaw(agent, server, rpKey, fId) {
async function downloadXFTPChunkRaw(agent, server, rpKey, fId, chunkSize) {
const { publicKey, privateKey } = generateX25519KeyPair();
const cmd = encodeFGET(encodePubKeyX25519(publicKey));
const { response, body } = await sendXFTPCommand(agent, server, rpKey, fId, cmd);
if (response.type !== "FRFile") throw new Error("unexpected response: " + response.type);
if (body.length !== chunkSize + authTagSize) throw new Error("chunk size mismatch");
const dhSecret = dh(response.rcvDhKey, privateKey);
return { dhSecret, nonce: response.nonce, body };
}
async function downloadXFTPChunk(agent, server, rpKey, fId, digest) {
const { dhSecret, nonce, body } = await downloadXFTPChunkRaw(agent, server, rpKey, fId);
async function downloadXFTPChunk(agent, server, rpKey, fId, chunkSize, digest) {
const { dhSecret, nonce, body } = await downloadXFTPChunkRaw(agent, server, rpKey, fId, chunkSize);
return decryptReceivedChunk(dhSecret, nonce, body, digest ?? null);
}
@@ -11161,18 +11166,18 @@ async function downloadFileRaw(agent, fd, onRawChunk, options) {
let downloaded = 0;
const byServer = /* @__PURE__ */ new Map();
for (const chunk of resolvedFd.chunks) {
const srv = chunk.replicas[0]?.server ?? "";
if (!byServer.has(srv)) byServer.set(srv, []);
byServer.get(srv).push(chunk);
const server = parseXFTPServer(chunk.replicas[0]?.server ?? "");
const key = formatXFTPServer(server);
if (!byServer.has(key)) byServer.set(key, { server, chunks: [] });
byServer.get(key).chunks.push(chunk);
}
await Promise.all([...byServer.entries()].map(async ([srv, chunks]) => {
const server = parseXFTPServer(srv);
await Promise.all([...byServer.values()].map(async ({ server, chunks }) => {
for (const chunk of chunks) {
const replica = chunk.replicas[0];
if (!replica) throw new Error("downloadFileRaw: chunk has no replicas");
const seed = decodePrivKeyEd25519(replica.replicaKey);
const kp = ed25519KeyPairFromSeed(seed);
const raw = await downloadXFTPChunkRaw(agent, server, kp.privateKey, replica.replicaId);
const raw = await downloadXFTPChunkRaw(agent, server, kp.privateKey, replica.replicaId, chunk.chunkSize);
await onRawChunk({
chunkNo: chunk.chunkNo,
dhSecret: raw.dhSecret,
@@ -11194,7 +11199,7 @@ async function resolveRedirect(agent, fd) {
const server = parseXFTPServer(replica.server);
const seed = decodePrivKeyEd25519(replica.replicaKey);
const kp = ed25519KeyPairFromSeed(seed);
const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.digest);
const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.chunkSize, chunk.digest);
plaintextChunks[chunk.chunkNo - 1] = data;
}
const totalSize = plaintextChunks.reduce((s, c) => s + c.length, 0);
@@ -11301,13 +11306,17 @@ function initUpload(app) {
stage.hidden = false;
}
function showError(msg) {
errorMsg.innerHTML = msg;
errorMsg.textContent = msg;
showStage(errorStage);
}
function showErrorHTML(html) {
errorMsg.innerHTML = html;
showStage(errorStage);
}
async function startUpload(file) {
aborted = false;
if (file.size > MAX_SIZE) {
showError(t("fileTooLarge", "File too large (%size%). Maximum is 100 MB. The SimpleX app supports files up to 1 GB.").replace("%size%", formatSize$1(file.size)));
showErrorHTML(t("fileTooLarge", "File too large (%size%). Maximum is 100 MB. The SimpleX app supports files up to 1 GB.").replace("%size%", formatSize$1(file.size)));
return;
}
if (file.size === 0) {
@@ -11449,7 +11458,7 @@ function initDownload(app, hash) {
stage.hidden = false;
}
function showError(msg) {
errorMsg.innerHTML = msg;
errorMsg.textContent = msg;
showStage(errorStage);
}
if (wrongServer) {
@@ -11584,7 +11593,8 @@ window.__xftp_initApp = async () => {
main().catch((err) => {
const app = getAppElement();
if (app) {
app.innerHTML = `<div class="error"><p>${t("initError", "Failed to initialize: %error%").replace("%error%", err.message)}</p></div>`;
app.innerHTML = '<div class="error"><p></p></div>';
app.querySelector("p").textContent = t("initError", "Failed to initialize: %error%").replace("%error%", err.message);
}
console.error(err);
});
+121 -3
View File
@@ -20,6 +20,7 @@ import qualified Crypto.PubKey.Curve25519 as X25519
import qualified Crypto.PubKey.Ed25519 as Ed25519
import qualified Data.ByteArray as BA
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lazy as LB
import Data.Int (Int64)
import Data.List (intercalate)
@@ -194,7 +195,7 @@ xftpWebTests = do
pendingWith "TS project not compiled"
xftpWebSourceHygieneTests :: Spec
xftpWebSourceHygieneTests = describe "source hygiene" $
xftpWebSourceHygieneTests = describe "source hygiene" $ do
it "does not commit XFTP web debug logs that expose secrets or plaintext" $ do
let files =
[ "xftp-web/src/client.ts",
@@ -208,6 +209,17 @@ xftpWebSourceHygieneTests = describe "source hygiene" $
forM_ files $ \path -> do
contents <- B.readFile path
mapM_ (\marker -> contents `shouldNotSatisfy` B.isInfixOf marker) markers
it "renders XFTP web error messages as text" $ do
let files =
[ "xftp-web/web/download.ts",
"xftp-web/web/upload.ts",
"xftp-web/web/main.ts",
"apps/xftp-server/static/xftp-web-bundle/index.js"
]
messageAsHTML line = "innerHTML" `B.isInfixOf` line && any (`B.isInfixOf` line) ["msg", "message"]
forM_ files $ \path -> do
contents <- B.readFile path
(path, filter messageAsHTML $ BC.lines contents) `shouldBe` (path, [])
-- ── protocol/encoding ──────────────────────────────────────────────
@@ -2234,6 +2246,53 @@ tsDescriptionTests = describe "protocol/description" $ do
<> jsOut "new TextEncoder().encode(r || 'ok')"
tsResult `shouldBe` "chunks total size is different than file size"
it "incorrect chunk size" $ do
fixture <- B.readFile "tests/fixtures/file_description.yaml"
tsResult <-
callNode $
impDesc
<> "const yaml = new TextDecoder().decode("
<> jsUint8 fixture
<> ");"
<> "const fd = Desc.decodeFileDescription(yaml);"
<> "fd.chunks[3].chunkSize = 2097152;"
<> "fd.size += 1048576;"
<> "const r = Desc.validateFileDescription(fd);"
<> jsOut "new TextEncoder().encode(r || 'ok')"
tsResult `shouldBe` "incorrect chunk size"
it "redirect description size limit" $ do
fixture <- B.readFile "tests/fixtures/file_description.yaml"
tsResult <-
callNode $
impDesc
<> "const yaml = new TextDecoder().decode("
<> jsUint8 fixture
<> ");"
<> "const fd = Desc.decodeFileDescription(yaml);"
<> "fd.redirect = {size: 1024, digest: new Uint8Array(64)};"
<> "const tooLarge = Desc.validateFileDescription(fd);"
<> "fd.chunks = fd.chunks.slice(0, 1);"
<> "fd.size = fd.chunks[0].chunkSize;"
<> "const atLimit = Desc.validateFileDescription(fd);"
<> jsOut "new TextEncoder().encode([tooLarge || 'ok', atLimit || 'ok'].join(','))"
tsResult `shouldBe` "redirect file description is too large,ok"
it "no chunks" $ do
fixture <- B.readFile "tests/fixtures/file_description.yaml"
tsResult <-
callNode $
impDesc
<> "const yaml = new TextDecoder().decode("
<> jsUint8 fixture
<> ");"
<> "const fd = Desc.decodeFileDescription(yaml);"
<> "fd.chunks = [];"
<> "fd.size = 0;"
<> "const r = Desc.validateFileDescription(fd);"
<> jsOut "new TextEncoder().encode(r || 'ok')"
tsResult `shouldBe` "no chunks"
-- ── protocol/chunks ───────────────────────────────────────────────
tsChunkTests :: Spec
@@ -2863,6 +2922,12 @@ tsIntegrationTests = describe "integration" $ do
agentDeleteTest testXFTPServerConfigEd25519SNI "tests/fixtures/ed25519/ca.crt"
it "agent redirect: upload with redirect, download" $
agentRedirectTest testXFTPServerConfigEd25519SNI "tests/fixtures/ed25519/ca.crt"
it "agent download: accept only chunks of the size in the description" $
agentChunkSizeTest "r.server" "null" testXFTPServerConfigEd25519SNI "tests/fixtures/ed25519/ca.crt"
it "agent download: download chunks of one server in sequence for all its addresses" $
agentChunkSizeTest "r.server + ',' + chunkNo" "null" testXFTPServerConfigEd25519SNI "tests/fixtures/ed25519/ca.crt"
it "agent redirect: accept only chunks of the size in the description" $
agentChunkSizeTest "r.server" "{size: 1024, digest: new Uint8Array(64)}" testXFTPServerConfigEd25519SNI "tests/fixtures/ed25519/ca.crt"
it "cross-language: TS upload, Haskell download" $
tsUploadHaskellDownloadTest testXFTPServerConfigSNI "tests/fixtures/ca.crt"
it "cross-language: TS upload with redirect, Haskell download" $
@@ -2967,11 +3032,11 @@ fullRoundTripTest cfg caFile = do
\const rcvKeys = [K.encodePubKeyEd25519(rcvKp1.publicKey)];\
\const {senderId, recipientIds} = await createXFTPChunk(agent, server, sndKp.privateKey, file, rcvKeys, null);\
\await uploadXFTPChunk(agent, server, sndKp.privateKey, senderId, chunkData);\
\const dl1 = await downloadXFTPChunk(agent, server, rcvKp1.privateKey, recipientIds[0], digest);\
\const dl1 = await downloadXFTPChunk(agent, server, rcvKp1.privateKey, recipientIds[0], chunkData.length, digest);\
\const match1 = dl1.length === chunkData.length && dl1.every((b, i) => b === chunkData[i]);\
\const newIds = await addXFTPRecipients(agent, server, sndKp.privateKey, senderId,\
\ [K.encodePubKeyEd25519(rcvKp2.publicKey)]);\
\const dl2 = await downloadXFTPChunk(agent, server, rcvKp2.privateKey, newIds[0], digest);\
\const dl2 = await downloadXFTPChunk(agent, server, rcvKp2.privateKey, newIds[0], chunkData.length, digest);\
\const match2 = dl2.length === chunkData.length && dl2.every((b, i) => b === chunkData[i]);\
\await deleteXFTPChunk(agent, server, sndKp.privateKey, senderId);\
\closeXFTPAgent(agent);"
@@ -3110,6 +3175,59 @@ agentRedirectTest cfg caFile = do
<> jsOut "new Uint8Array([hasRedirect, nameMatch, sizeMatch, dataMatch])"
result `shouldBe` B.pack [1, 1, 1, 1]
agentChunkSizeTest :: HasTestEnv => String -> String -> XFTPServerConfig STMFileStore -> FilePath -> Expectation
agentChunkSizeTest replicaServer redirect cfg caFile = do
withXFTPServerCfg cfg $ \_ -> do
Fingerprint fp <- loadFileFingerprint caFile
let fpStr = map (toEnum . fromIntegral) $ B.unpack $ strEncode fp
addr = "xftp://" <> fpStr <> "@localhost:" <> xftpTestPort
result <-
callNode $
"import sodium from 'libsodium-wrappers-sumo';\
\import crypto from 'node:crypto';\
\import * as Addr from './dist/protocol/address.js';\
\import * as Agent from './dist/agent.js';\
\await sodium.ready;\
\const server = Addr.parseXFTPServer('"
<> addr
<> "');\
\const uploadAgent = Agent.newXFTPAgent();\
\const encrypted = Agent.encryptFileForUpload(new Uint8Array(crypto.randomBytes(200000)), 'chunk-size.bin');\
\const {rcvDescription} = await Agent.uploadFile(uploadAgent, [server], encrypted);\
\Agent.closeXFTPAgent(uploadAgent);\
\const [chunk] = rcvDescription.chunks;\
\const chunks = [1, 2, 3, 4].map(chunkNo => ({\
\ ...chunk, chunkNo, chunkSize: 65536, replicas: chunk.replicas.map(r => ({...r, server: "
<> replicaServer
<> "}))\
\}));\
\const fd = {...rcvDescription, size: 262144, chunkSize: 65536, chunks, redirect: "
<> redirect
<> "};\
\const agent = Agent.newXFTPAgent();\
\const connect = agent._connectFn;\
\let bodies = 0;\
\agent._connectFn = async (srv) => {\
\ const client = await connect(srv);\
\ const post = client.transport.post;\
\ client.transport.post = async (body, headers) => {\
\ const resp = await post(body, headers);\
\ if (resp.length > 16384) bodies++;\
\ return resp;\
\ };\
\ return client;\
\};\
\let stored = 0;\
\let outcome = 'downloaded';\
\try {\
\ await Agent.downloadFileRaw(agent, fd, async () => { stored++; });\
\} catch (e) {\
\ outcome = e.message;\
\}\
\Agent.closeXFTPAgent(agent);"
<> jsOut "new TextEncoder().encode([chunk.chunkSize, outcome, stored, bodies].join(','))"
result `shouldBe` "262144,chunk size mismatch,0,1"
tsUploadHaskellDownloadTest :: HasTestEnv => XFTPServerConfig STMFileStore -> FilePath -> Expectation
tsUploadHaskellDownloadTest cfg caFile = do
createDirectoryIfMissing False recipientFiles
+8 -8
View File
@@ -284,20 +284,20 @@ export async function downloadFileRaw(
const resolvedFd = fd
// Group chunks by server, sequential within each server, parallel across servers
let downloaded = 0
const byServer = new Map<string, typeof resolvedFd.chunks>()
const byServer = new Map<string, {server: XFTPServer, chunks: typeof resolvedFd.chunks}>()
for (const chunk of resolvedFd.chunks) {
const srv = chunk.replicas[0]?.server ?? ""
if (!byServer.has(srv)) byServer.set(srv, [])
byServer.get(srv)!.push(chunk)
const server = parseXFTPServer(chunk.replicas[0]?.server ?? "")
const key = formatXFTPServer(server)
if (!byServer.has(key)) byServer.set(key, {server, chunks: []})
byServer.get(key)!.chunks.push(chunk)
}
await Promise.all([...byServer.entries()].map(async ([srv, chunks]) => {
const server = parseXFTPServer(srv)
await Promise.all([...byServer.values()].map(async ({server, chunks}) => {
for (const chunk of chunks) {
const replica = chunk.replicas[0]
if (!replica) throw new Error("downloadFileRaw: chunk has no replicas")
const seed = decodePrivKeyEd25519(replica.replicaKey)
const kp = ed25519KeyPairFromSeed(seed)
const raw = await downloadXFTPChunkRaw(agent, server, kp.privateKey, replica.replicaId)
const raw = await downloadXFTPChunkRaw(agent, server, kp.privateKey, replica.replicaId, chunk.chunkSize)
await onRawChunk({
chunkNo: chunk.chunkNo,
dhSecret: raw.dhSecret,
@@ -341,7 +341,7 @@ async function resolveRedirect(
const server = parseXFTPServer(replica.server)
const seed = decodePrivKeyEd25519(replica.replicaKey)
const kp = ed25519KeyPairFromSeed(seed)
const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.digest)
const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.chunkSize, chunk.digest)
plaintextChunks[chunk.chunkNo - 1] = data
}
const totalSize = plaintextChunks.reduce((s, c) => s + c.length, 0)
+5 -3
View File
@@ -24,6 +24,7 @@ import type {XFTPServer} from "./protocol/address.js"
import {formatXFTPServer} from "./protocol/address.js"
import {concatBytes} from "./protocol/encoding.js"
import {blockUnpad} from "./protocol/transmission.js"
import {authTagSize} from "./protocol/chunks.js"
// -- Error types
@@ -401,20 +402,21 @@ export interface RawChunkResponse {
}
export async function downloadXFTPChunkRaw(
agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array
agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array, chunkSize: number
): Promise<RawChunkResponse> {
const {publicKey, privateKey} = generateX25519KeyPair()
const cmd = encodeFGET(encodePubKeyX25519(publicKey))
const {response, body} = await sendXFTPCommand(agent, server, rpKey, fId, cmd)
if (response.type !== "FRFile") throw new Error("unexpected response: " + response.type)
if (body.length !== chunkSize + authTagSize) throw new Error("chunk size mismatch")
const dhSecret = dh(response.rcvDhKey, privateKey)
return {dhSecret, nonce: response.nonce, body}
}
export async function downloadXFTPChunk(
agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array, digest?: Uint8Array
agent: XFTPClientAgent, server: XFTPServer, rpKey: Uint8Array, fId: Uint8Array, chunkSize: number, digest?: Uint8Array
): Promise<Uint8Array> {
const {dhSecret, nonce, body} = await downloadXFTPChunkRaw(agent, server, rpKey, fId)
const {dhSecret, nonce, body} = await downloadXFTPChunkRaw(agent, server, rpKey, fId, chunkSize)
return decryptReceivedChunk(dhSecret, nonce, body, digest ?? null)
}
+4 -1
View File
@@ -3,11 +3,14 @@
// Computes chunk sizes for file uploads, chunk specifications with offsets,
// and per-chunk SHA-256 digests.
import {kb, mb} from "./description.js"
import {sha256} from "../crypto/digest.js"
// -- Chunk size constants (Simplex.FileTransfer.Chunks)
export const kb = (n: number): number => n * 1024
export const mb = (n: number): number => n * 1048576
export const gb = (n: number): number => n * 1073741824
export const chunkSize0 = kb(64) // 65536
export const chunkSize1 = kb(256) // 262144
export const chunkSize2 = mb(1) // 1048576
+5 -4
View File
@@ -3,6 +3,8 @@
// Handles YAML-encoded file descriptions matching Haskell Data.Yaml output format.
// Base64url encoding matches Haskell Data.ByteString.Base64.URL.encode (with padding).
import {chunkSize3, serverChunkSizes} from "./chunks.js"
// -- Base64url (RFC 4648 section 5) with '=' padding
const B64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
@@ -63,10 +65,6 @@ export function base64urlDecode(s: string): Uint8Array {
// -- FileSize encoding/decoding
export const kb = (n: number): number => n * 1024
export const mb = (n: number): number => n * 1048576
export const gb = (n: number): number => n * 1073741824
export function encodeFileSize(bytes: number): string {
const ks = Math.floor(bytes / 1024)
if (bytes % 1024 !== 0) return String(bytes)
@@ -351,12 +349,15 @@ function parseReplicaField(
// -- Validation
export function validateFileDescription(fd: FileDescription): string | null {
if (fd.chunks.length === 0) return "no chunks"
for (let i = 0; i < fd.chunks.length; i++) {
if (fd.chunks[i].chunkNo !== i + 1) return "chunk numbers are not sequential"
}
let total = 0
for (const c of fd.chunks) total += c.chunkSize
if (total !== fd.size) return "chunks total size is different than file size"
if (fd.chunks.some(c => !serverChunkSizes.includes(c.chunkSize))) return "incorrect chunk size"
if (fd.redirect !== null && fd.size > chunkSize3) return "redirect file description is too large"
return null
}
+1 -1
View File
@@ -64,7 +64,7 @@ export function initDownload(app: HTMLElement, hash: string) {
}
function showError(msg: string) {
errorMsg.innerHTML = msg
errorMsg.textContent = msg
showStage(errorStage)
}
+2 -1
View File
@@ -48,7 +48,8 @@ function initApp() {
main().catch(err => {
const app = getAppElement()
if (app) {
app.innerHTML = `<div class="error"><p>${t('initError', 'Failed to initialize: %error%').replace('%error%', err.message)}</p></div>`
app.innerHTML = '<div class="error"><p></p></div>'
app.querySelector('p')!.textContent = t('initError', 'Failed to initialize: %error%').replace('%error%', err.message)
}
console.error(err)
})
+7 -2
View File
@@ -98,7 +98,12 @@ export function initUpload(app: HTMLElement) {
}
function showError(msg: string) {
errorMsg.innerHTML = msg
errorMsg.textContent = msg
showStage(errorStage)
}
function showErrorHTML(html: string) {
errorMsg.innerHTML = html
showStage(errorStage)
}
@@ -107,7 +112,7 @@ export function initUpload(app: HTMLElement) {
aborted = false
if (file.size > MAX_SIZE) {
showError(t('fileTooLarge', 'File too large (%size%). Maximum is 100 MB. The SimpleX app supports files up to 1 GB.').replace('%size%', formatSize(file.size)))
showErrorHTML(t('fileTooLarge', 'File too large (%size%). Maximum is 100 MB. The SimpleX app supports files up to 1 GB.').replace('%size%', formatSize(file.size)))
return
}
if (file.size === 0) {