src/snapshot.js
Alle Dateien · Rohdatei öffnen
// Copyright 2026 Richard Andresik. SPDX-License-Identifier: Apache-2.0
// Review snapshot: exact excerpts from IcyZip's browser client.
// These functions require application state or the supplied test adapter.
// See THREAT-MODEL.md before relying on this protocol.
// BEGIN exact source section: module-integration
function textE2eeSupported()
{
return !!(window.IcyZipE2EE && window.crypto && window.crypto.subtle
&& window.crypto.getRandomValues && window.TextEncoder && window.TextDecoder);
}
function readPairSecret(id)
{
if (pairSecretId === id && window.IcyZipE2EE.validSecret(pairSecret)) return pairSecret;
try
{
const saved = sessionStorage.getItem(window.IcyZipE2EE.SECRET_PREFIX + id);
return window.IcyZipE2EE.validSecret(saved) ? saved : null;
}
catch (error) { return null; }
}
function usePairSecret(id, secret)
{
if (!id || !window.IcyZipE2EE.validSecret(secret)) return false;
if (pairSecretId !== id || pairSecret !== secret) resetTextE2eeSecret();
pairSecretId = id;
pairSecret = secret;
try { sessionStorage.setItem(window.IcyZipE2EE.SECRET_PREFIX + id, secret); }
catch (error) {}
return true;
}
function ensureTextE2eeSession(id)
{
const secret = readPairSecret(id);
if (!id || !secret || !textE2eeSupported()) throw new Error("Pair key missing");
if (!e2eeSession || e2eeSessionId !== id)
{
let storage = null;
try { storage = sessionStorage; } catch (error) {}
e2eeSession = window.IcyZipE2EE.createSession({
pairId: id, role: isPrimaryView() ? "primary" : "secondary",
secret, crypto: window.crypto, storage
});
e2eeSessionId = id;
}
return e2eeSession;
}
function clearUrlFragment()
{
if (!location.hash) return;
try { history.replaceState(null, document.title, location.pathname + location.search); }
catch (error) {}
}
function clearPairIdFromUrl()
{
try
{
const next = new URL(location.href);
next.searchParams.delete("i");
history.replaceState(null, document.title, next.pathname + next.search + next.hash);
}
catch (error) {}
}
function clearTextE2eeDerivedSecret()
{
if (e2eeSession) e2eeSession.resetPeer();
}
function resetTextE2eeSecret()
{
if (e2eeSession) e2eeSession.close();
e2eeSession = null;
e2eeSessionId = "";
pairSecret = null;
pairSecretId = "";
textE2eeReadyCallbacks = [];
}
function clearTextE2eeSecretForId(id)
{
if (!id) return;
try
{
for (const prefix of [window.IcyZipE2EE.SECRET_PREFIX, window.IcyZipE2EE.KEYPAIR_PREFIX,
"icyzip.textE2ee.v1:", "icyzip.textE2ee.ecdh.v2:"])
sessionStorage.removeItem(prefix + id);
}
catch (error) {}
if (pairSecretId === id || e2eeSessionId === id) resetTextE2eeSecret();
}
function textE2eeReady()
{
return !!(e2eeSession && e2eeSessionId === currentTextE2eePairId() && e2eeSession.ready());
}
function onTextE2eeReady(callback)
{
if (typeof callback !== "function") return;
if (textE2eeReady()) callback();
else textE2eeReadyCallbacks.push(callback);
}
function notifyTextE2eeReady()
{
if (!textE2eeReady()) return;
const callbacks = textE2eeReadyCallbacks;
textE2eeReadyCallbacks = [];
callbacks.forEach(function (callback) { callback(); });
}
function currentTextE2eePairId()
{
return pairId || i || (requestedResumePair && requestedResumePair.id) || "";
}
function pairUrlForId(id)
{
const secret = id && readPairSecret(id);
return secret ? publicBaseUrl + "/?i=" + encodeURIComponent(id)
+ window.IcyZipE2EE.fragmentForSecret(secret) : "";
}
function showTextE2eeFailure(state, diagnosticReason)
{
const status = state === "key-mismatch" ? "Pair key mismatch" : "Pair key missing";
sendClientDiagnostic(diagnosticReason || state);
setStatusMessage(status);
setUiState(state, status);
}
async function receiveTextE2eePublic(message)
{
const session = ensureTextE2eeSession(currentTextE2eePairId());
const accepted = await session.acceptPublicMessage(message);
if (accepted && session === e2eeSession) notifyTextE2eeReady();
return accepted;
}
async function sendTextE2eePublic()
{
const id = currentTextE2eePairId();
const targetId = isPrimaryView() ? aid : i;
if (!id || !targetId) return false;
try
{
const session = ensureTextE2eeSession(id);
const message = await session.publicMessage();
return session === e2eeSession && sendCommand("textPub", [targetId].concat(message));
}
catch (error)
{
showTextE2eeFailure("key-missing", "e2ee-unsupported");
return false;
}
}
async function encryptTextPayload(text, updatedAt, origin)
{
const revision = normalizedTextUpdatedAt(updatedAt) || TEXT_REVISION_BASE;
const sender = typeof origin === "string" && origin ? origin : localTextUpdatedOrigin;
return ensureTextE2eeSession(currentTextE2eePairId()).encryptText(String(text || ""), revision, sender);
}
async function decryptTextPayload(payload)
{
return ensureTextE2eeSession(currentTextE2eePairId()).decryptText(payload);
}
async function encryptFileChunk(buffer, transferId, seq)
{
return ensureTextE2eeSession(currentTextE2eePairId()).encryptFile(arrayBufferCopy(buffer), transferId, seq);
}
async function decryptFileChunk(buffer, transferId, seq)
{
return ensureTextE2eeSession(currentTextE2eePairId()).decryptFile(arrayBufferCopy(buffer), transferId, seq);
}
function isPrimaryView()
{
return i == null;
}
// END exact source section: module-integration
// BEGIN exact source section: file-buffers
function fileByteLength(data)
{
if (data instanceof ArrayBuffer)
{
return data.byteLength;
}
if (ArrayBuffer.isView(data))
{
return data.byteLength;
}
return 0;
}
function arrayBufferCopy(data)
{
if (data instanceof ArrayBuffer)
{
return data.slice(0);
}
if (ArrayBuffer.isView(data))
{
return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
}
return new ArrayBuffer(0);
}
function isBinaryMessageData(data)
{
return data instanceof ArrayBuffer || ArrayBuffer.isView(data);
}
function readBlobAsArrayBuffer(blob)
{
return new Promise(function (resolve, reject)
{
const reader = new FileReader();
reader.onload = function () { resolve(reader.result); };
reader.onerror = function () { reject(reader.error || new Error("file read failed")); };
reader.readAsArrayBuffer(blob);
});
}
function safeDownloadName(value)
{
const name = String(value || "")
.replace(/[\\\/]/g, " ")
.replace(/[\x00-\x1f\x7f]/g, " ")
.trim()
.slice(0, 180);
return name || "download";
}
// END exact source section: file-buffers
// BEGIN exact source section: file-controller
function createFileTransferController()
{
const input = document.getElementById("fileInput");
const sendButton = document.getElementById("fileActionSend");
const cancelButton = document.getElementById("fileActionCancel");
const progress = document.getElementById("fileProgress");
const status = document.getElementById("fileStatus");
const download = document.getElementById("fileReceivedDownload");
const state = {
selectedFile: null,
outgoing: null,
incoming: null,
pendingOffer: null,
receivedUrl: ""
};
function controlsAvailable()
{
return fileTransferRuntimeEnabled && input && sendButton && cancelButton && progress && status && download;
}
function setFileStatus(text)
{
if (status)
{
const key = textKey(text);
if (key)
{
status.dataset.i18nKey = key;
status.textContent = t(key);
}
else
{
delete status.dataset.i18nKey;
status.textContent = text || "";
}
}
updateFileActionButtons();
}
function updateFileActionButtons()
{
const available = Boolean(fileTransferRuntimeEnabled && input && sendButton && cancelButton && progress && status && download);
const active = Boolean(state.outgoing || state.incoming || state.pendingOffer);
if (sendButton)
{
sendButton.disabled = !available || active;
sendButton.setAttribute("aria-disabled", sendButton.disabled ? "true" : "false");
}
if (cancelButton)
{
cancelButton.disabled = !available || !active;
cancelButton.setAttribute("aria-disabled", cancelButton.disabled ? "true" : "false");
}
}
function setFileProgress(value, max)
{
if (!progress)
{
return;
}
progress.max = Math.max(1, Number(max) || 100);
progress.value = Math.max(0, Math.min(progress.max, Number(value) || 0));
}
function clearDownload()
{
if (state.receivedUrl)
{
URL.revokeObjectURL(state.receivedUrl);
}
state.receivedUrl = "";
if (download)
{
download.hidden = true;
download.removeAttribute("href");
download.removeAttribute("download");
download.textContent = t("action.download");
}
}
function showDownload(name, blob)
{
clearDownload();
state.receivedUrl = URL.createObjectURL(blob);
download.href = state.receivedUrl;
download.download = safeDownloadName(name);
download.textContent = t("action.download");
download.hidden = false;
}
function activeTransferId()
{
if (state.outgoing)
{
return state.outgoing.id;
}
if (state.incoming)
{
return state.incoming.id;
}
if (state.pendingOffer) return state.pendingOffer.id;
return "";
}
function clearActiveTransfer(text)
{
state.outgoing = null;
state.incoming = null;
state.pendingOffer = null;
setFileProgress(0, 100);
setFileStatus(text || "Ready");
}
function cancelActiveTransfer(notifyPeer, text)
{
const transferId = activeTransferId();
if (notifyPeer && transferId)
{
sendCommand("fileCancel", [transferId, "cancelled"]);
}
clearActiveTransfer(text || "Cancelled");
}
function selectedFileLabel(file)
{
if (!file)
{
return "file.ready";
}
return safeDownloadName(file.name) + " selected";
}
function filePlainChunkSize(file)
{
const maxPlainChunk = Math.max(1, fileChunkBytes - FILE_E2EE_FRAME_OVERHEAD);
return Math.max(1, Math.min(maxPlainChunk, file.size));
}
function encryptedWireSize(fileSize, plainChunkSize)
{
const chunks = Math.ceil(fileSize / plainChunkSize);
return fileSize + chunks * FILE_E2EE_FRAME_OVERHEAD;
}
function updateSelectedFile()
{
if (!controlsAvailable())
{
return;
}
state.selectedFile = input.files && input.files.length > 0 ? input.files[0] : null;
if (!state.outgoing && !state.incoming && !state.pendingOffer)
{
setFileProgress(0, 100);
setFileStatus(selectedFileLabel(state.selectedFile));
}
}
async function sendNextChunk(transfer)
{
if (!state.outgoing || state.outgoing.id !== transfer.id)
{
return;
}
if (transfer.offset >= transfer.file.size)
{
sendCommand("fileDone", [transfer.id, String(transfer.totalChunks), String(transfer.wireSize)]);
setFileStatus("Finishing");
return;
}
const end = Math.min(transfer.offset + transfer.chunkSize, transfer.file.size);
const buffer = await readBlobAsArrayBuffer(transfer.file.slice(transfer.offset, end));
const encryptedBuffer = await encryptFileChunk(buffer, transfer.id, transfer.seq);
if (!state.outgoing || state.outgoing.id !== transfer.id)
{
return;
}
transfer.pendingPlainBytes = fileByteLength(buffer);
transfer.pendingBytes = fileByteLength(encryptedBuffer);
transfer.awaitingAck = true;
if (!sendCommand("fileChunk", [transfer.id, String(transfer.seq), String(transfer.pendingBytes)])
|| !sendBinaryFrame(encryptedBuffer))
{
clearActiveTransfer("Connection lost");
return;
}
setFileStatus("Sending");
}
async function sendSelectedFile()
{
if (!controlsAvailable())
{
return;
}
clearDownload();
updateSelectedFile();
const file = state.selectedFile;
if (!file)
{
setFileStatus("Choose a file");
return;
}
if (file.size <= 0)
{
setFileStatus("Empty file");
return;
}
if (file.size > fileMaxBytes)
{
setFileStatus("File too large");
return;
}
if (document.body.dataset.wsState !== "connected")
{
setFileStatus("Peer offline");
return;
}
if (!textE2eeReady())
{
setFileStatus("Transfer failed");
return;
}
if (state.outgoing || state.incoming || state.pendingOffer)
{
setFileStatus("Transfer active");
return;
}
const chunkSize = filePlainChunkSize(file);
const wireSize = encryptedWireSize(file.size, chunkSize);
if (wireSize <= file.size)
{
setFileStatus("Transfer failed");
return;
}
const transfer = {
id: newTransferId(),
file,
chunkSize,
wireSize,
encryptedChunkSize: chunkSize + FILE_E2EE_FRAME_OVERHEAD,
totalChunks: Math.ceil(file.size / chunkSize),
offset: 0,
seq: 0,
pendingBytes: 0,
pendingPlainBytes: 0,
awaitingAck: false
};
state.outgoing = transfer;
setFileProgress(0, file.size);
setFileStatus("Waiting for peer");
const session = ensureTextE2eeSession(currentTextE2eePairId());
const offer = await session.signFileOffer([
transfer.id,
safeDownloadName(file.name),
String(file.size),
file.type || "application/octet-stream",
String(transfer.encryptedChunkSize),
String(wireSize),
"e2ee-v3"
]);
if (state.outgoing === transfer && session === e2eeSession)
sendCommand("fileOffer", offer);
}
async function handleFileOffer(args)
{
if (!controlsAvailable())
{
sendCommand("fileReject", [args[0] || "", "disabled"]);
return;
}
const transferId = args[0] || "";
const name = safeDownloadName(args[1]);
const size = Number(args[2]);
const mime = args[3] || "application/octet-stream";
const chunkSize = Number(args[4]);
const wireSize = Number(args[5]);
if (state.outgoing || state.incoming || state.pendingOffer)
{
sendCommand("fileReject", [transferId, "busy"]);
return;
}
if (args[6] !== "e2ee-v3" || !textE2eeReady())
{
sendCommand("fileReject", [transferId, "encryption-required"]);
setFileStatus("file.encryptionRequired");
return;
}
if (!transferId || !Number.isSafeInteger(size) || size <= 0 || size > fileMaxBytes
|| !Number.isSafeInteger(chunkSize) || chunkSize <= FILE_E2EE_FRAME_OVERHEAD || chunkSize > fileChunkBytes
|| !Number.isSafeInteger(wireSize) || wireSize <= size)
{
sendCommand("fileReject", [transferId, "invalid"]);
return;
}
const pending = { id: transferId };
state.pendingOffer = pending;
updateFileActionButtons();
const session = ensureTextE2eeSession(currentTextE2eePairId());
let verified = false;
try { verified = await session.verifyFileOffer(args); }
catch (error) {}
if (state.pendingOffer !== pending) return;
state.pendingOffer = null;
if (!verified || session !== e2eeSession || !textE2eeReady())
{
sendCommand("fileReject", [transferId, "encryption-required"]);
setFileStatus("file.encryptionRequired");
return;
}
clearDownload();
state.incoming = {
id: transferId,
name,
size,
wireSize,
mime,
chunkSize,
expectedSeq: 0,
receivedBytes: 0,
receivedPlainBytes: 0,
parts: [],
pending: null
};
setFileProgress(0, size);
setFileStatus("Receiving");
sendCommand("fileAccept", [transferId]);
}
function handleFileAccept(args)
{
const transferId = args[0] || "";
if (!state.outgoing || state.outgoing.id !== transferId)
{
return;
}
sendNextChunk(state.outgoing).catch(function ()
{
cancelActiveTransfer(true, "Read failed");
});
}
function handleFileChunk(args)
{
const transferId = args[0] || "";
const seq = Number(args[1]);
const byteLength = Number(args[2]);
const transfer = state.incoming;
if (!transfer || transfer.id !== transferId || !Number.isInteger(seq) || seq !== transfer.expectedSeq
|| !Number.isInteger(byteLength) || byteLength <= 0 || byteLength > transfer.chunkSize
|| transfer.receivedBytes + byteLength > transfer.wireSize)
{
cancelActiveTransfer(true, "Transfer failed");
return;
}
transfer.pending = {
seq,
byteLength
};
setFileStatus("Receiving");
}
function handleBinary(data)
{
const transfer = state.incoming;
if (!transfer || !transfer.pending)
{
return;
}
const byteLength = fileByteLength(data);
if (byteLength !== transfer.pending.byteLength)
{
cancelActiveTransfer(true, "Transfer failed");
return;
}
const pending = transfer.pending;
decryptFileChunk(data, transfer.id, pending.seq).then(function (plain)
{
const current = state.incoming;
if (!current || current.id !== transfer.id || current.pending !== pending)
{
return;
}
const plainBytes = fileByteLength(plain);
if (plainBytes <= 0 || current.receivedPlainBytes + plainBytes > current.size)
{
cancelActiveTransfer(true, "Transfer failed");
return;
}
current.parts.push(arrayBufferCopy(plain));
current.receivedBytes += byteLength;
current.receivedPlainBytes += plainBytes;
current.expectedSeq += 1;
current.pending = null;
setFileProgress(current.receivedPlainBytes, current.size);
sendCommand("fileChunkAck", [current.id, String(pending.seq)]);
}).catch(function ()
{
cancelActiveTransfer(true, "Transfer failed");
});
}
function handleFileChunkAck(args)
{
const transferId = args[0] || "";
const seq = Number(args[1]);
const transfer = state.outgoing;
if (!transfer || transfer.id !== transferId || seq !== transfer.seq || !transfer.awaitingAck)
{
return;
}
transfer.offset += transfer.pendingPlainBytes;
transfer.seq += 1;
transfer.pendingBytes = 0;
transfer.pendingPlainBytes = 0;
transfer.awaitingAck = false;
setFileProgress(transfer.offset, transfer.file.size);
sendNextChunk(transfer).catch(function ()
{
cancelActiveTransfer(true, "Read failed");
});
}
function handleFileDone(args)
{
const transferId = args[0] || "";
const totalBytes = Number(args[2]);
const transfer = state.incoming;
if (!transfer || transfer.id !== transferId || transfer.pending || totalBytes !== transfer.wireSize
|| transfer.receivedBytes !== transfer.wireSize || transfer.receivedPlainBytes !== transfer.size)
{
cancelActiveTransfer(true, "Transfer failed");
return;
}
const blob = new Blob(transfer.parts, { type: transfer.mime || "application/octet-stream" });
showDownload(transfer.name, blob);
sendCommand("fileReceived", [transfer.id]);
state.incoming = null;
setFileProgress(totalBytes, transfer.size);
setFileStatus("Received");
}
function handleFileReceived(args)
{
const transferId = args[0] || "";
if (!state.outgoing || state.outgoing.id !== transferId)
{
return;
}
state.outgoing = null;
setFileProgress(100, 100);
setFileStatus("Sent");
}
function handleFileFinishedByPeer(text)
{
clearActiveTransfer(text);
}
function handleCommand(cmd, args)
{
switch (cmd)
{
case "fileOffer":
handleFileOffer(args);
return true;
case "fileAccept":
handleFileAccept(args);
return true;
case "fileChunk":
handleFileChunk(args);
return true;
case "fileChunkAck":
handleFileChunkAck(args);
return true;
case "fileDone":
handleFileDone(args);
return true;
case "fileReceived":
handleFileReceived(args);
return true;
case "fileReject":
handleFileFinishedByPeer("Rejected");
return true;
case "fileCancel":
handleFileFinishedByPeer("Cancelled");
return true;
case "fileError":
handleFileFinishedByPeer("Transfer failed");
return true;
default:
return false;
}
}
function bind()
{
if (!controlsAvailable())
{
setFileProgress(0, 100);
setFileStatus(fileTransferRuntimeEnabled ? "Unavailable" : "Disabled");
return;
}
input.onchange = updateSelectedFile;
sendButton.onclick = function ()
{
sendSelectedFile().catch(function ()
{
cancelActiveTransfer(true, "Read failed");
});
};
cancelButton.onclick = function ()
{
cancelActiveTransfer(true, "Cancelled");
};
setFileProgress(0, 100);
setFileStatus(selectedFileLabel(state.selectedFile));
}
return {
bind,
handleCommand,
handleBinary,
cancelLocal: function (text)
{
clearActiveTransfer(text || "Ready");
}
};
}
// END exact source section: file-controller