tools/fuzz.mjs
Alle Dateien · Rohdatei öffnen
// Copyright 2026 Richard Andresik. SPDX-License-Identifier: Apache-2.0
// Seed controls synthetic inputs and mutations, never cryptographic entropy.
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { paired, E2EE } from "../test/endpoint.mjs";
export async function fuzz({ seed = 1387, iterations = 256, makePair = paired } = {}) {
assert.ok(Number.isInteger(seed) && seed > 0 && seed <= 0xffffffff, "seed must be an integer from 1 to 4294967295");
assert.ok(Number.isInteger(iterations) && iterations > 0 && iterations <= 100000,
"iterations must be an integer from 1 to 100000");
let state = seed >>> 0;
const next = () => {
state ^= state << 13; state ^= state >>> 17; state ^= state << 5;
return state >>> 0;
};
const pick = size => next() % size;
const plan = createHash("sha256");
const peers = await makePair();
let rejected = 0;
let roundTrips = 0;
const changeBytes = (value, offset, bit) => {
const bytes = Buffer.from(value, "base64url");
bytes[offset % bytes.length] ^= 1 << bit;
return bytes.toString("base64url");
};
try {
for (let index = 0; index < iterations; index++) {
const [sender, receiver] = index % 2 ? [peers.secondary, peers.primary] : [peers.primary, peers.secondary];
const selector = Array.from({ length: 12 }, () => next());
const length = [0, 1, 7, 255, 4096, 65536][index % 6];
const text = "🧊\u0000\n漢字" + Array.from({ length }, () => String.fromCharCode(32 + pick(95))).join("");
const plain = Uint8Array.from({ length: 1 + selector[0] % 4096 }, () => pick(256));
plan.update(JSON.stringify([index, selector, text, Buffer.from(plain).toString("base64")]));
try {
const pub = await sender.session.publicMessage();
const alteredPub = pub.slice();
alteredPub[2] = changeBytes(pub[2], selector[1], selector[2] % 8);
await assert.rejects(receiver.session.acceptPublicMessage(alteredPub), "altered key authenticator accepted");
rejected++;
await receiver.session.acceptPublicMessage(pub);
const wire = await sender.session.encryptText(text, index + 1, "fuzz-" + sender.role);
const altered = JSON.parse(wire);
switch (selector[3] % 6) {
case 0: altered.c = changeBytes(altered.c, selector[4], selector[5] % 8); break;
case 1: altered.n = changeBytes(altered.n, selector[4], selector[5] % 8); break;
case 2: altered.c = altered.c.slice(0, -4); break;
case 3: altered.v = 1; break;
case 4: altered.alg = "A128GCM"; break;
case 5: altered.o = "relay"; break;
}
await assert.rejects(receiver.session.decryptText(JSON.stringify(altered)), "altered text accepted");
rejected++;
assert.deepEqual(await receiver.session.decryptText(wire),
{ text, updatedAt: index + 1, origin: "fuzz-" + sender.role });
roundTrips++;
const transfer = "fuzz-file-" + index;
const frame = new Uint8Array(await sender.session.encryptFile(plain, transfer, index));
const badFrame = frame.slice();
badFrame[selector[6] % frame.length] ^= 1 << (selector[7] % 8);
await assert.rejects(receiver.session.decryptFile(badFrame, transfer, index), "altered file accepted");
rejected++;
assert.deepEqual(new Uint8Array(await receiver.session.decryptFile(frame, transfer, index)), plain);
roundTrips++;
const fields = [transfer, "synthetic.bin", String(plain.length), "application/octet-stream",
String(frame.length), String(frame.length), "e2ee-v3"];
const offer = await sender.session.signFileOffer(fields);
const badOffer = offer.slice();
const field = selector[8] % 8;
badOffer[field] = field === 7 ? changeBytes(offer[7], selector[9], selector[10] % 8) : offer[field] + "1";
assert.equal(await receiver.session.verifyFileOffer(badOffer).catch(() => false), false, "altered offer accepted");
rejected++;
assert.equal(await receiver.session.verifyFileOffer(offer), true);
const fragment = E2EE.fragmentForSecret(sender.secret);
const badFragment = [fragment + "&v=3", fragment + "&extra=1", fragment.replace("v=3", "v=2"),
fragment.replace("#k=", "#k=!")][selector[11] % 4];
assert.equal(E2EE.parseFragment(badFragment), null, "malformed link accepted");
rejected++;
assert.equal(E2EE.parseFragment(fragment), sender.secret);
const reply = await receiver.session.encryptText("reply " + index, index + 2, "fuzz-reply");
assert.equal((await sender.session.decryptText(reply)).text, "reply " + index);
const progress = await sender.session.encryptText("after rejection " + index, index + 3, "fuzz-progress");
assert.equal((await receiver.session.decryptText(progress)).text, "after rejection " + index);
roundTrips += 2;
} catch (error) {
throw new Error("fuzz seed=" + seed + " iteration=" + index + ": " + error.message, { cause: error });
}
}
} finally {
peers.primary.session.close(); peers.secondary.session.close();
}
return { seed, iterations, rejected, roundTrips, planSha256: plan.digest("hex") };
}
if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
try {
const options = {};
for (let index = 2; index < process.argv.length; index += 2) {
const key = process.argv[index];
assert.ok(["--seed", "--iterations"].includes(key), "Use --seed INTEGER and --iterations INTEGER");
assert.ok(process.argv[index + 1] !== undefined, key + " requires an integer");
options[key.slice(2)] = Number(process.argv[index + 1]);
}
console.log(JSON.stringify({ result: "fuzz-pass", ...await fuzz(options) }));
} catch (error) {
console.error(error.message);
process.exitCode = 1;
}
}