Dateitransfer: Server, Seiten, Tests und Docker-Dateien

Hochladen mit Upload-Code, kurzer Link zum Herunterladen, automatische
Löschung nach Ablauf der Frist. Node.js ohne zusätzliche Pakete.

- src/: HTTP-Server, Ablage auf der Platte, Zugriffsbegrenzung
- pages/, public/: Oberfläche in Deutsch und Englisch
- tools/: Transfers auflisten und löschen
- test/: 34 automatische Tests
- Dockerfile, compose.yaml: Betrieb als Container auf 127.0.0.1:8083

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
DerSchandfleckandClaude Fable 5.2 committed 2026-11-16 00:59:41 +01:00
1 parent 51ff6f9d40
commit 278194b707
31 files changed
+5099

No files matched your search

+714
View File
@@ -0,0 +1,714 @@
import assert from 'node:assert/strict';
import fs from 'node:fs/promises';
import path from 'node:path';
import { Readable } from 'node:stream';
import { test } from 'node:test';
import {
CODE,
createTransfer,
finish,
putChunk,
randomFile,
rawRequest,
sleep,
startApp,
uploadAll,
} from './helpers.js';
const JSON_HEADERS = { 'Content-Type': 'application/json' };
test('Seiten und statische Dateien', async (t) => {
const ctx = await startApp({ SITE_NAME: 'Test & <Seite>' });
t.after(() => ctx.stop());
const home = await fetch(`${ctx.base}/`);
assert.equal(home.status, 200);
assert.match(home.headers.get('content-type'), /^text\/html/);
const html = await home.text();
assert.ok(html.includes('Test &amp; &lt;Seite&gt;'), 'Seitenname wird maskiert eingesetzt');
assert.equal(html.includes('{{'), false, 'keine Platzhalter übrig');
// Schutz-Header auf jeder Antwort
assert.match(home.headers.get('content-security-policy'), /default-src 'none'/);
assert.equal(home.headers.get('x-content-type-options'), 'nosniff');
assert.equal(home.headers.get('x-frame-options'), 'DENY');
assert.equal(home.headers.get('referrer-policy'), 'no-referrer');
// Unveränderte Seite: 304 statt erneuter Übertragung
const again = await fetch(`${ctx.base}/`, { headers: { 'If-None-Match': home.headers.get('etag') } });
assert.equal(again.status, 304);
const css = await fetch(`${ctx.base}/css/style.css`);
assert.equal(css.status, 200);
assert.match(css.headers.get('content-type'), /^text\/css/);
const js = await fetch(`${ctx.base}/js/upload.js`);
assert.match(js.headers.get('content-type'), /^text\/javascript/);
assert.equal((await fetch(`${ctx.base}/favicon.svg`)).headers.get('content-type'), 'image/svg+xml');
assert.match(await (await fetch(`${ctx.base}/robots.txt`)).text(), /Disallow: \//);
const head = await fetch(`${ctx.base}/`, { method: 'HEAD' });
assert.equal(head.status, 200);
assert.equal(await head.text(), '');
const missing = await fetch(`${ctx.base}/gibt-es-nicht`);
assert.equal(missing.status, 404);
assert.match(await missing.text(), /Seite nicht gefunden/);
const apiMissing = await fetch(`${ctx.base}/api/gibt-es-nicht`);
assert.equal(apiMissing.status, 404);
assert.deepEqual(await apiMissing.json(), { error: 'not_found' });
const wrongMethod = await fetch(`${ctx.base}/`, { method: 'POST' });
assert.equal(wrongMethod.status, 405);
assert.equal(wrongMethod.headers.get('allow'), 'GET, HEAD');
assert.equal((await fetch(`${ctx.base}/healthz`)).status, 200);
});
test('Pfade außerhalb von public/ sind nicht erreichbar', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
for (const target of [
'/../server.js',
'/css/../../server.js',
'/css/%2e%2e/%2e%2e/server.js',
'/..%2f.env',
'/.env',
'/server.js',
'/src/app.js',
'/pages/index.html',
'/index.html',
'//etc/passwd',
]) {
const res = await rawRequest(ctx.port, { method: 'GET', path: target });
assert.equal(res.status, 404, target);
}
});
test('Einstellungen für die Oberfläche', async (t) => {
const ctx = await startApp({ MAX_TRANSFER_SIZE: '10MB', MAX_FILES: '5', EXPIRY_DAYS: '1,3' });
t.after(() => ctx.stop());
const res = await fetch(`${ctx.base}/api/config`);
assert.equal(res.headers.get('cache-control'), 'no-store');
assert.deepEqual(await res.json(), {
uploadsEnabled: true,
codeRequired: true,
maxTransferBytes: 10 * 1024 ** 2,
maxFiles: 5,
expiryDays: [1, 3],
defaultExpiryDays: 1,
});
});
test('Hochladen in Stücken, abrufen und herunterladen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const files = [
randomFile('Urlaub 2026 – Ägäis (1).jpg', 700_000), // drei Stücke
randomFile('leer.txt', 0),
randomFile('../../boese/pfad.bin', 1234),
];
const transfer = await uploadAll(ctx.base, files, { expiryDays: 1 });
assert.match(transfer.id, /^[2-9a-hjkmnp-z]{10}$/);
const expectedExpiry = Date.now() + 86_400_000;
assert.ok(Math.abs(transfer.expiresAt - expectedExpiry) < 10_000);
const info = await (await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).json();
assert.equal(info.id, transfer.id);
assert.equal(info.totalBytes, 701_234);
assert.deepEqual(info.files, [
{ name: 'Urlaub 2026 – Ägäis (1).jpg', size: 700_000 },
{ name: 'leer.txt', size: 0 },
{ name: 'pfad.bin', size: 1234 },
]);
assert.equal('deleteTokenHash' in info || 'uploadTokenHash' in info, false);
// Auf der Platte liegen nur Nummern, keine Namen der Nutzer
const stored = (await fs.readdir(path.join(ctx.dataDir, 'transfers', transfer.id))).sort();
assert.deepEqual(stored, ['0', '1', '2', 'meta.json']);
for (let index = 0; index < files.length; index++) {
const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`);
assert.equal(res.status, 200);
assert.equal(res.headers.get('content-type'), 'application/octet-stream');
assert.equal(res.headers.get('x-content-type-options'), 'nosniff');
assert.match(res.headers.get('content-security-policy'), /sandbox/);
assert.match(res.headers.get('content-disposition'), /^attachment; /);
assert.equal(res.headers.get('content-length'), String(files[index].data.length));
assert.deepEqual(Buffer.from(await res.arrayBuffer()), files[index].data);
}
const disposition = (await fetch(`${ctx.base}/d/${transfer.id}/0`, { method: 'HEAD' })).headers.get(
'content-disposition',
);
assert.ok(disposition.includes("filename*=UTF-8''Urlaub%202026%20%E2%80%93%20%C3%84g%C3%A4is%20%281%29.jpg"));
// Teilabrufe (zum Fortsetzen abgebrochener Downloads)
const data = files[0].data;
const part = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=100-199' } });
assert.equal(part.status, 206);
assert.equal(part.headers.get('content-range'), `bytes 100-199/${data.length}`);
assert.deepEqual(Buffer.from(await part.arrayBuffer()), data.subarray(100, 200));
const tail = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=-50' } });
assert.equal(tail.status, 206);
assert.deepEqual(Buffer.from(await tail.arrayBuffer()), data.subarray(data.length - 50));
const rest = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=699990-' } });
assert.equal(rest.status, 206);
assert.deepEqual(Buffer.from(await rest.arrayBuffer()), data.subarray(699_990));
const beyond = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=700000-' } });
assert.equal(beyond.status, 416);
assert.equal(beyond.headers.get('content-range'), `bytes */${data.length}`);
const stale = await fetch(`${ctx.base}/d/${transfer.id}/0`, {
headers: { Range: 'bytes=0-9', 'If-Range': '"anderer-stand"' },
});
assert.equal(stale.status, 200, 'veralteter If-Range liefert die ganze Datei');
await stale.arrayBuffer();
// Datei-Nummern außerhalb der Liste
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/3`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/meta.json`)).status, 404);
// Download-Seite; die Kennung gilt auch in Großbuchstaben
const page = await fetch(`${ctx.base}/d/${transfer.id}`);
assert.equal(page.status, 200);
assert.match(await page.text(), /data-state="loading"/);
assert.equal(page.headers.get('x-robots-tag'), 'noindex, nofollow');
assert.equal((await fetch(`${ctx.base}/d/${transfer.id.toUpperCase()}`)).status, 200);
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id.toUpperCase()}`)).status, 200);
assert.ok(ctx.logs.some((line) => line.includes(`Transfer ${transfer.id} angelegt`) && line.includes('"test"')));
assert.equal(ctx.logs.some((line) => line.includes(CODE)), false, 'der Code selbst steht nie im Protokoll');
});
test('Ohne gültigen Upload-Code wird nichts angelegt', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
const none = await createTransfer(ctx.base, [file], { code: undefined });
assert.equal(none.res.status, 401);
assert.equal(none.body.error, 'code_required');
const wrong = await createTransfer(ctx.base, [file], { code: 'falsch' });
assert.equal(wrong.res.status, 401);
assert.equal(wrong.body.error, 'code_invalid');
const padded = await createTransfer(ctx.base, [file], { code: ` ${CODE}\n` });
assert.equal(padded.res.status, 201, 'Leerzeichen um den Code stören nicht');
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 1);
});
test('Zu viele falsche Codes sperren die Adresse vorübergehend', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
for (let i = 0; i < 10; i++) {
assert.equal((await createTransfer(ctx.base, [file], { code: `falsch-${i}` })).res.status, 401);
}
const blocked = await createTransfer(ctx.base, [file]);
assert.equal(blocked.res.status, 429);
assert.equal(blocked.body.error, 'rate_limited');
assert.ok(Number(blocked.res.headers.get('retry-after')) > 0);
assert.equal(blocked.body.retryAfter, Number(blocked.res.headers.get('retry-after')));
});
test('Hinter einem Proxy zählt die weitergereichte Adresse', async (t) => {
const direct = await startApp();
const proxied = await startApp({ TRUST_PROXY: '1' });
t.after(() => Promise.all([direct.stop(), proxied.stop()]));
const file = randomFile('a.txt', 10);
// Mit TRUST_PROXY wird je weitergereichter Adresse gezählt …
for (let i = 0; i < 10; i++) {
await createTransfer(proxied.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': '198.51.100.1' });
}
const sameIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.1' });
assert.equal(sameIp.res.status, 429);
const otherIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.2' });
assert.equal(otherIp.res.status, 201);
// … und nur der letzte Eintrag gilt, den der eigene Proxy angehängt hat.
const spoofed = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '203.0.113.9, 198.51.100.1' });
assert.equal(spoofed.res.status, 429);
// Ohne TRUST_PROXY lässt sich die Sperre nicht mit dem Header umgehen.
for (let i = 0; i < 10; i++) {
await createTransfer(direct.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': `198.51.100.${i}` });
}
const stillBlocked = await createTransfer(direct.base, [file], {}, { 'X-Forwarded-For': '203.0.113.50' });
assert.equal(stillBlocked.res.status, 429);
});
test('Grenzen und fehlerhafte Anfragen', async (t) => {
const ctx = await startApp({ MAX_TRANSFER_SIZE: '1MB', MAX_FILES: '3' });
t.after(() => ctx.stop());
const post = (body, headers = JSON_HEADERS) =>
fetch(`${ctx.base}/api/transfers`, { method: 'POST', headers, body });
const error = async (res) => (await res.json()).error;
const tooLarge = await post(JSON.stringify({ code: CODE, files: [{ name: 'a', size: 1024 ** 2 + 1 }] }));
assert.equal(tooLarge.status, 413);
assert.deepEqual(await tooLarge.json(), { error: 'too_large', maxBytes: 1024 ** 2 });
const sumTooLarge = await post(
JSON.stringify({ code: CODE, files: [{ name: 'a', size: 600_000 }, { name: 'b', size: 600_000 }] }),
);
assert.equal(sumTooLarge.status, 413);
const tooMany = await post(
JSON.stringify({ code: CODE, files: Array.from({ length: 4 }, (_, i) => ({ name: `f${i}`, size: 1 })) }),
);
assert.equal(tooMany.status, 413);
assert.deepEqual(await tooMany.json(), { error: 'too_many_files', maxFiles: 3 });
for (const files of [
undefined,
[],
'text',
[{ name: 'a' }],
[{ name: 'a', size: -1 }],
[{ name: 'a', size: 1.5 }],
[{ name: 'a', size: '5' }],
[{ name: 5, size: 5 }],
[{ name: 'x'.repeat(2000), size: 5 }],
[null],
]) {
const res = await post(JSON.stringify({ code: CODE, files }));
assert.equal(res.status, 400, JSON.stringify(files)?.slice(0, 40));
}
const badExpiry = await post(JSON.stringify({ code: CODE, expiryDays: 365, files: [{ name: 'a', size: 1 }] }));
assert.equal(badExpiry.status, 400);
assert.equal(await error(await post('{kein json')), 'invalid_json');
assert.equal(await error(await post('[1,2]')), 'invalid_request');
const form = await post('code=x', { 'Content-Type': 'application/x-www-form-urlencoded' });
assert.equal(form.status, 415);
const huge = await rawRequest(ctx.port, {
method: 'POST',
path: '/api/transfers',
headers: JSON_HEADERS,
body: Buffer.from('{"code":"'),
declaredLength: 10_000_000,
});
assert.equal(huge.status, 413);
assert.equal(huge.json.error, 'body_too_large');
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0, 'nichts wurde angelegt');
});
test('Regeln beim stückweisen Hochladen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 400_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
const chunk = transfer.chunkBytes;
assert.equal(chunk, 256 * 1024);
// Vor dem Abschluss ist nichts öffentlich sichtbar
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404);
// Falsches oder fehlendes Token
const foreign = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 10), transfer.deleteToken);
assert.equal(foreign.res.status, 403);
const noToken = await fetch(`${ctx.base}/api/transfers/${transfer.id}/files/0?offset=0`, {
method: 'PUT',
body: file.data.subarray(0, 10),
});
assert.equal(noToken.status, 403);
// Falsche Stelle: Der Server nennt den richtigen Stand
const ahead = await putChunk(ctx.base, transfer, 0, 5000, file.data.subarray(5000, 6000));
assert.equal(ahead.res.status, 409);
assert.deepEqual(ahead.body, { error: 'offset_mismatch', received: 0 });
// Zu großes Stück, unbekannte Datei, unsinnige Stelle
const oversized = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk + 1));
assert.equal(oversized.res.status, 413);
assert.equal((await putChunk(ctx.base, transfer, 1, 0, file.data.subarray(0, 10))).res.status, 404);
assert.equal((await putChunk(ctx.base, transfer, 0, 'abc', file.data.subarray(0, 10))).res.status, 400);
const first = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk));
assert.deepEqual(first.body, { received: chunk });
// Dasselbe Stück noch einmal: wird abgelehnt, nichts wird doppelt geschrieben
const repeat = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk));
assert.equal(repeat.res.status, 409);
assert.equal(repeat.body.received, chunk);
// Mehr als zur Datei gehört
const overflow = await putChunk(ctx.base, transfer, 0, chunk, Buffer.alloc(400_000 - chunk + 1));
assert.equal(overflow.res.status, 413);
// Zu früh abschließen
const early = await finish(ctx.base, transfer);
assert.equal(early.res.status, 409);
assert.equal(early.body.error, 'incomplete');
const status = await fetch(`${ctx.base}/api/transfers/${transfer.id}/upload`, {
headers: { Authorization: `Bearer ${transfer.uploadToken}` },
});
assert.deepEqual(await status.json(), {
state: 'uploading',
expiresAt: null,
files: [{ size: 400_000, received: chunk }],
});
const last = await putChunk(ctx.base, transfer, 0, chunk, file.data.subarray(chunk));
assert.deepEqual(last.body, { received: 400_000 });
const done = await finish(ctx.base, transfer);
assert.equal(done.res.status, 200);
// Abschließen ist wiederholbar (falls die Antwort verloren ging)
const doneAgain = await finish(ctx.base, transfer);
assert.equal(doneAgain.res.status, 200);
assert.equal(doneAgain.body.expiresAt, done.body.expiresAt);
// Nach dem Abschluss lässt sich nichts mehr überschreiben
const late = await putChunk(ctx.base, transfer, 0, 400_000, Buffer.alloc(0));
assert.equal(late.res.status, 409);
assert.equal(late.body.error, 'not_uploading');
const download = await fetch(`${ctx.base}/d/${transfer.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});
test('Fehlermeldung kommt an, auch wenn der Browser noch sendet', async (t) => {
// Große Stücke, damit der Körper nicht einfach in den Netzwerkpuffern verschwindet.
const ctx = await startApp({ CHUNK_SIZE: '8MB' });
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 9_000_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
const headers = { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' };
// Stück an falscher Stelle: Die Antwort 409 muss trotz großem Körper lesbar sein.
const wrongPlace = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=1000`,
headers,
body: file.data.subarray(1000, 8_001_000),
declaredLength: 8_000_000,
});
assert.equal(wrongPlace.status, 409);
assert.deepEqual(wrongPlace.json, { error: 'offset_mismatch', received: 0 });
assert.notEqual(wrongPlace.headers.connection, 'close', 'die Verbindung bleibt nutzbar');
// Falsches Token: genauso
const forbidden = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers: { ...headers, Authorization: `Bearer ${'x'.repeat(43)}` },
body: file.data.subarray(0, 8_000_000),
declaredLength: 8_000_000,
});
assert.equal(forbidden.status, 403);
// Mehr angekündigt als erlaubt: Der Server wartet den Körper gar nicht erst ab.
const tooBig = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers,
body: file.data.subarray(0, 1000),
declaredLength: 500_000_000,
});
assert.equal(tooBig.status, 413);
assert.equal(tooBig.headers.connection, 'close');
// Danach funktioniert der Upload normal weiter.
const ok = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 8 * 1024 ** 2));
assert.deepEqual(ok.body, { received: 8 * 1024 ** 2 });
});
test('Abgebrochenes Stück lässt sich wiederholen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 200_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
// Verbindung reißt mitten im Stück ab
const aborted = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers: { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' },
body: file.data.subarray(0, 50_000),
declaredLength: 200_000,
abort: true,
});
assert.equal(aborted.aborted, true);
// Der Server zählt das halbe Stück nicht und nimmt es danach vollständig an.
let retry;
for (let i = 0; i < 40; i++) {
retry = await putChunk(ctx.base, transfer, 0, 0, file.data);
if (retry.res.status !== 409 || retry.body.error !== 'busy') break;
await sleep(50);
}
assert.equal(retry.res.status, 200);
assert.deepEqual(retry.body, { received: 200_000 });
assert.equal((await finish(ctx.base, transfer)).res.status, 200);
const download = await fetch(`${ctx.base}/d/${transfer.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});
test('Löschen nur mit dem Lösch-Token', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 5000)]);
const dir = path.join(ctx.dataDir, 'transfers', transfer.id);
const del = (token) =>
fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: token ? { Authorization: `Bearer ${token}` } : {},
});
assert.equal((await del()).status, 403);
assert.equal((await del(transfer.uploadToken)).status, 403);
assert.equal((await del('x'.repeat(43))).status, 403);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 200);
assert.equal((await del(transfer.deleteToken)).status, 204);
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404);
await assert.rejects(fs.access(dir));
assert.equal((await del(transfer.deleteToken)).status, 404);
});
test('Ein angefangener Upload lässt sich verwerfen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.bin', 5000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 1000));
const res = await fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: { Authorization: `Bearer ${transfer.deleteToken}` },
});
assert.equal(res.status, 204);
assert.equal((await putChunk(ctx.base, transfer, 0, 1000, file.data.subarray(1000))).res.status, 404);
assert.equal(ctx.app.store.size, 0);
});
test('Abgelaufene und liegen gebliebene Transfers werden entfernt', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const ready = await uploadAll(ctx.base, [randomFile('a.bin', 100)]);
const kept = await uploadAll(ctx.base, [randomFile('b.bin', 100)]);
const { body: unfinished } = await createTransfer(ctx.base, [randomFile('c.bin', 100)]);
const dirOf = (id) => path.join(ctx.dataDir, 'transfers', id);
// Frist abgelaufen: sofort nicht mehr abrufbar, auch vor dem Aufräumen
ctx.app.store.get(ready.id).expiresAt = Date.now() - 1;
assert.equal((await fetch(`${ctx.base}/api/transfers/${ready.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${ready.id}/0`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${ready.id}`)).status, 404);
// Upload, an dem lange nichts mehr passiert ist
ctx.app.store.get(unfinished.id).lastActivity = Date.now() - ctx.config.staleUploadMs - 1;
assert.equal(await ctx.app.store.sweep(), 2);
await assert.rejects(fs.access(dirOf(ready.id)));
await assert.rejects(fs.access(dirOf(unfinished.id)));
await fs.access(dirOf(kept.id));
assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 200);
// Ordner von Hand gelöscht: Der Eintrag verschwindet beim nächsten Aufräumen
await fs.rm(dirOf(kept.id), { recursive: true });
assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 404);
assert.equal(await ctx.app.store.sweep(), 1);
assert.equal(ctx.app.store.size, 0);
});
test('Nach einem Neustart ist alles wieder da', async (t) => {
const first = await startApp();
const files = [randomFile('fertig.bin', 300_000)];
const ready = await uploadAll(first.base, files);
const partial = randomFile('halb.bin', 600_000);
const { body: uploading } = await createTransfer(first.base, [partial]);
await putChunk(first.base, uploading, 0, 0, partial.data.subarray(0, 256 * 1024));
await first.stop({ keepData: true });
const second = await startApp({}, { dataDir: first.dataDir });
t.after(() => second.stop());
assert.equal(second.app.store.size, 2);
const download = await fetch(`${second.base}/d/${ready.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), files[0].data);
const info = await (await fetch(`${second.base}/api/transfers/${ready.id}`)).json();
assert.equal(info.expiresAt, ready.expiresAt);
// Der angefangene Upload geht an der alten Stelle weiter
const status = await fetch(`${second.base}/api/transfers/${uploading.id}/upload`, {
headers: { Authorization: `Bearer ${uploading.uploadToken}` },
});
assert.equal((await status.json()).files[0].received, 256 * 1024);
let offset = 256 * 1024;
while (offset < partial.data.length) {
const result = await putChunk(second.base, uploading, 0, offset, partial.data.subarray(offset, offset + 256 * 1024));
assert.equal(result.res.status, 200);
offset = result.body.received;
}
assert.equal((await finish(second.base, uploading)).res.status, 200);
const resumed = await fetch(`${second.base}/d/${uploading.id}/0`);
assert.deepEqual(Buffer.from(await resumed.arrayBuffer()), partial.data);
});
test('Beschädigte Ordner im Datenverzeichnis stören den Start nicht', async (t) => {
const first = await startApp();
const ready = await uploadAll(first.base, [randomFile('a.bin', 100)]);
await first.stop({ keepData: true });
const transfers = path.join(first.dataDir, 'transfers');
await fs.mkdir(path.join(transfers, 'abcdefgh23'));
await fs.writeFile(path.join(transfers, 'abcdefgh23', 'meta.json'), '{kaputt');
await fs.mkdir(path.join(transfers, 'bcdefgh234'));
await fs.writeFile(
path.join(transfers, 'bcdefgh234', 'meta.json'),
JSON.stringify({ v: 1, id: 'ein-anderer', state: 'ready', files: [] }),
);
await fs.mkdir(path.join(transfers, 'kein-transfer'));
await fs.writeFile(path.join(transfers, 'notiz.txt'), 'hallo');
const second = await startApp({}, { dataDir: first.dataDir });
t.after(() => second.stop());
assert.equal(second.app.store.size, 1);
assert.equal((await fetch(`${second.base}/d/${ready.id}/0`)).status, 200);
assert.equal(second.logs.filter((line) => line.includes('übersprungen')).length, 2);
assert.equal((await fetch(`${second.base}/d/abcdefgh23`)).status, 404);
});
test('Kennungen lassen sich nicht in großem Stil durchprobieren', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 100)]);
for (let i = 0; i < 60; i++) {
const res = await fetch(`${ctx.base}/api/transfers/2222222222`);
assert.equal(res.status, 404);
}
const api = await fetch(`${ctx.base}/api/transfers/2222222222`);
assert.equal(api.status, 429);
assert.ok(Number(api.headers.get('retry-after')) > 0);
// Die Sperre gilt dann auch für Seiten und Dateien …
const page = await fetch(`${ctx.base}/d/${transfer.id}`);
assert.equal(page.status, 429);
await page.text();
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 429);
// … aber nicht für die Startseite.
assert.equal((await fetch(`${ctx.base}/`)).status, 200);
});
test('Ohne Upload-Codes ist das Hochladen gesperrt', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: '' });
t.after(() => ctx.stop());
const config = await (await fetch(`${ctx.base}/api/config`)).json();
assert.equal(config.uploadsEnabled, false);
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]);
assert.equal(res.res.status, 503);
assert.equal(res.body.error, 'uploads_disabled');
});
test('Mit OPEN_UPLOADS geht es ohne Code', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: '', OPEN_UPLOADS: '1' });
t.after(() => ctx.stop());
const config = await (await fetch(`${ctx.base}/api/config`)).json();
assert.deepEqual([config.uploadsEnabled, config.codeRequired], [true, false]);
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)], { code: undefined });
assert.equal(res.res.status, 201);
});
test('Mehrere Codes; jeder wird im Protokoll mit Namen geführt', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: 'anna:annas-geheimnis,ben:bens-geheimnis' });
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
assert.equal((await createTransfer(ctx.base, [file], { code: 'annas-geheimnis' })).res.status, 201);
assert.equal((await createTransfer(ctx.base, [file], { code: 'bens-geheimnis' })).res.status, 201);
assert.equal((await createTransfer(ctx.base, [file], { code: 'anna' })).res.status, 401);
assert.equal((await createTransfer(ctx.base, [file], { code: 'anna:annas-geheimnis' })).res.status, 401);
assert.ok(ctx.logs.some((line) => line.includes('Code "anna"')));
assert.ok(ctx.logs.some((line) => line.includes('Code "ben"')));
});
test('Das Speicherkontingent wird eingehalten', async (t) => {
const ctx = await startApp({ STORAGE_QUOTA: '1MB', MIN_FREE_SPACE: '0' });
t.after(() => ctx.stop());
const post = (size) =>
fetch(`${ctx.base}/api/transfers`, {
method: 'POST',
headers: JSON_HEADERS,
body: JSON.stringify({ code: CODE, files: [{ name: 'a.bin', size }] }),
});
const first = await post(700_000);
assert.equal(first.status, 201);
const second = await post(400_000);
assert.equal(second.status, 507);
assert.deepEqual(await second.json(), { error: 'storage_full' });
assert.equal((await post(300_000)).status, 201);
// Nach dem Löschen ist der Platz wieder frei
const transfer = await first.json();
await fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: { Authorization: `Bearer ${transfer.deleteToken}` },
});
assert.equal((await post(700_000)).status, 201);
});
test('Zu wenig freier Plattenplatz wird vorher bemerkt', async (t) => {
// Verlangt mehr freien Platz, als irgendeine Platte hat.
const ctx = await startApp({ MIN_FREE_SPACE: '900000TB' });
t.after(() => ctx.stop());
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]);
assert.equal(res.res.status, 507);
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0);
});
test('Gleichzeitige Uploads kommen sich nicht in die Quere', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const sets = Array.from({ length: 6 }, (_, i) => [randomFile(`a${i}.bin`, 300_000 + i), randomFile(`b${i}.bin`, 1000 + i)]);
const transfers = await Promise.all(sets.map((files) => uploadAll(ctx.base, files)));
assert.equal(new Set(transfers.map((tr) => tr.id)).size, 6);
await Promise.all(
transfers.map(async (transfer, i) => {
for (let index = 0; index < 2; index++) {
const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`);
assert.deepEqual(Buffer.from(await res.arrayBuffer()), sets[i][index].data);
}
}),
);
});
test('Eine abgerissene Verbindung blockiert die Datei nicht', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 1000);
const { body: created } = await createTransfer(ctx.base, [file]);
const transfer = ctx.app.store.get(created.id);
// Verbindung ist schon weg, bevor das Schreiben beginnt
const gone = new Readable({ read() {} });
gone.destroy();
await assert.rejects(ctx.app.store.writeChunk(transfer, 0, 0, gone, 1000));
// Verbindung reißt mitten im Schreiben ab
const breaking = new Readable({ read() {} });
const pending = ctx.app.store.writeChunk(transfer, 0, 0, breaking, 1000);
breaking.push(file.data.subarray(0, 400));
await sleep(20);
breaking.destroy();
await assert.rejects(pending);
assert.equal(transfer.files[0].received, 0);
assert.equal(transfer.files[0].busy, false);
// Danach lässt sich die Datei ganz normal hochladen
const ok = await putChunk(ctx.base, created, 0, 0, file.data);
assert.deepEqual(ok.body, { received: 1000 });
assert.equal((await finish(ctx.base, created)).res.status, 200);
const download = await fetch(`${ctx.base}/d/${created.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});
+129
View File
@@ -0,0 +1,129 @@
// Gemeinsames für die Tests: eine frische Instanz mit eigenem Datenordner.
import { randomBytes } from 'node:crypto';
import fs from 'node:fs/promises';
import http from 'node:http';
import os from 'node:os';
import path from 'node:path';
import { createApp } from '../src/app.js';
import { loadConfig } from '../src/config.js';
export const rootDir = path.resolve(import.meta.dirname, '..');
export const CODE = 'test-code-123';
export async function startApp(env = {}, { dataDir } = {}) {
const dir = dataDir ?? (await fs.mkdtemp(path.join(os.tmpdir(), 'filetransfer-test-')));
const config = loadConfig(
{ DATA_DIR: dir, HOST: '127.0.0.1', PORT: '0', UPLOAD_CODES: `test:${CODE}`, CHUNK_SIZE: '256KB', ...env },
{ rootDir },
);
const logs = [];
const app = await createApp(config, { log: (message) => logs.push(message) });
const address = await app.listen();
return {
app,
config,
logs,
dataDir: dir,
base: `http://127.0.0.1:${address.port}`,
port: address.port,
/** Beendet den Server; der Datenordner bleibt nur mit keepData erhalten. */
async stop({ keepData = false } = {}) {
await app.close({ graceMs: 200 });
if (!keepData) await fs.rm(dir, { recursive: true, force: true });
},
};
}
export function randomFile(name, size) {
return { name, data: randomBytes(size) };
}
export async function createTransfer(base, files, extra = {}, headers = {}) {
const res = await fetch(`${base}/api/transfers`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', ...headers },
body: JSON.stringify({
code: CODE,
files: files.map((file) => ({ name: file.name, size: file.data.length })),
...extra,
}),
});
return { res, body: await res.json() };
}
export async function putChunk(base, transfer, index, offset, data, token = transfer.uploadToken) {
const res = await fetch(`${base}/api/transfers/${transfer.id}/files/${index}?offset=${offset}`, {
method: 'PUT',
headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/octet-stream' },
body: data,
});
return { res, body: await res.json().catch(() => null) };
}
export async function finish(base, transfer, token = transfer.uploadToken) {
const res = await fetch(`${base}/api/transfers/${transfer.id}/finish`, {
method: 'POST',
headers: { Authorization: `Bearer ${token}` },
});
return { res, body: await res.json().catch(() => null) };
}
/** Legt einen Transfer an, lädt alles stückweise hoch und schließt ihn ab. */
export async function uploadAll(base, files, extra = {}) {
const { res, body: transfer } = await createTransfer(base, files, extra);
if (res.status !== 201) throw new Error(`Anlegen fehlgeschlagen: ${res.status} ${JSON.stringify(transfer)}`);
for (let index = 0; index < files.length; index++) {
const { data } = files[index];
for (let offset = 0; offset < data.length; ) {
const piece = data.subarray(offset, offset + transfer.chunkBytes);
const result = await putChunk(base, transfer, index, offset, piece);
if (result.res.status !== 200) throw new Error(`Stück fehlgeschlagen: ${result.res.status}`);
offset = result.body.received;
}
}
const done = await finish(base, transfer);
if (done.res.status !== 200) throw new Error(`Abschließen fehlgeschlagen: ${done.res.status}`);
return { ...transfer, expiresAt: done.body.expiresAt };
}
/**
* Anfrage auf unterster Ebene, um Sonderfälle nachzustellen: `declaredLength`
* kündigt mehr an, als `body` liefert; mit `abort` wird danach getrennt.
*/
export function rawRequest(port, { method, path: target, headers = {}, body, declaredLength, abort = false }) {
return new Promise((resolve, reject) => {
const req = http.request({
host: '127.0.0.1',
port,
method,
path: target,
headers: { ...headers, ...(declaredLength !== undefined ? { 'Content-Length': declaredLength } : {}) },
});
req.on('response', (res) => {
const chunks = [];
res.on('data', (chunk) => chunks.push(chunk));
res.on('end', () => {
const text = Buffer.concat(chunks).toString('utf8');
let json = null;
try {
json = JSON.parse(text);
} catch {
json = null;
}
resolve({ status: res.statusCode, headers: res.headers, text, json });
});
});
req.on('error', (err) => (abort ? resolve({ aborted: true }) : reject(err)));
if (body) req.write(body);
if (abort) {
setTimeout(() => {
req.destroy();
resolve({ aborted: true });
}, 100);
} else if (declaredLength === undefined || (body?.length ?? 0) >= declaredLength) {
req.end();
}
});
}
export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+131
View File
@@ -0,0 +1,131 @@
import assert from 'node:assert/strict';
import { test } from 'node:test';
import { loadConfig, parseCodes, parseSize } from '../src/config.js';
import { RateLimiter } from '../src/limiter.js';
import { ID_PATTERN, contentDisposition, hashEquals, ipKey, randomId, sanitizeName, sha256 } from '../src/util.js';
test('parseSize versteht übliche Schreibweisen', () => {
assert.equal(parseSize('1024'), 1024);
assert.equal(parseSize('1KB'), 1024);
assert.equal(parseSize('8 MB'), 8 * 1024 ** 2);
assert.equal(parseSize('5GB'), 5 * 1024 ** 3);
assert.equal(parseSize('5GiB'), 5 * 1024 ** 3);
assert.equal(parseSize('1,5g'), 1.5 * 1024 ** 3);
assert.throws(() => parseSize('viel'));
assert.throws(() => parseSize('5 XB'));
assert.throws(() => parseSize('-5GB'));
});
test('parseCodes liest Namen und Codes, behält aber nur Hashes', () => {
const codes = parseCodes('freunde:apfel-kuchen-73, anna:kurz\nohne-namen-123');
assert.deepEqual(
codes.map((c) => c.label),
['freunde', 'anna', 'code3'],
);
assert.equal(codes[0].hash, sha256('apfel-kuchen-73'));
assert.equal(codes[0].short, false);
assert.equal(codes[1].short, true);
assert.equal(JSON.stringify(codes).includes('apfel'), false);
assert.deepEqual(parseCodes(''), []);
assert.throws(() => parseCodes('a:eins-zwei-drei,a:vier-fuenf-sechs'), /doppelt/);
assert.throws(() => parseCodes('name:'), /fehlt/);
});
test('loadConfig setzt Vorgaben und meldet Unsinn', () => {
const cfg = loadConfig({}, { rootDir: '/srv/app' });
assert.equal(cfg.port, 8083);
assert.equal(cfg.host, '127.0.0.1');
assert.equal(cfg.dataDir, '/srv/app/data');
assert.deepEqual(cfg.expiryDays, [1, 7, 30]);
assert.equal(cfg.defaultExpiryDays, 7);
assert.equal(cfg.openUploads, false);
assert.deepEqual(cfg.codes, []);
assert.equal(loadConfig({ DATA_DIR: '/var/x' }, { rootDir: '/srv/app' }).dataDir, '/var/x');
assert.deepEqual(loadConfig({ EXPIRY_DAYS: '30, 3,3' }, { rootDir: '/' }).expiryDays, [3, 30]);
assert.equal(loadConfig({ EXPIRY_DAYS: '3,30' }, { rootDir: '/' }).defaultExpiryDays, 3);
assert.throws(() => loadConfig({ PORT: 'abc' }, { rootDir: '/' }), /PORT/);
assert.throws(() => loadConfig({ EXPIRY_DAYS: '0' }, { rootDir: '/' }), /EXPIRY_DAYS/);
assert.throws(() => loadConfig({ DEFAULT_EXPIRY_DAYS: '5' }, { rootDir: '/' }), /DEFAULT_EXPIRY_DAYS/);
assert.throws(() => loadConfig({ MAX_TRANSFER_SIZE: 'riesig' }, { rootDir: '/' }), /MAX_TRANSFER_SIZE/);
assert.throws(() => loadConfig({ CHUNK_SIZE: '1GB' }, { rootDir: '/' }), /CHUNK_SIZE/);
});
test('randomId passt zum Muster', () => {
for (let i = 0; i < 200; i++) assert.match(randomId(), ID_PATTERN);
assert.equal(ID_PATTERN.test('abcdefghi1'), false); // enthält i und 1
assert.equal(ID_PATTERN.test('../../etc'), false);
});
test('hashEquals vergleicht nur gleich lange, gültige Hashes', () => {
assert.equal(hashEquals(sha256('a'), sha256('a')), true);
assert.equal(hashEquals(sha256('a'), sha256('b')), false);
assert.equal(hashEquals('', ''), false);
assert.equal(hashEquals(sha256('a'), 'abcd'), false);
});
test('ipKey fasst IPv6-Adressen zu /64-Netzen zusammen', () => {
assert.equal(ipKey('203.0.113.7'), '203.0.113.7');
assert.equal(ipKey('::ffff:203.0.113.7'), '203.0.113.7');
assert.equal(ipKey('2001:db8:1:2:aaaa:bbbb:cccc:dddd'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:db8:1:2::1'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:0db8:0001:0002::ffff'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:db8::1'), '2001:db8:0:0::/64');
assert.equal(ipKey('::1'), '0:0:0:0::/64');
assert.equal(ipKey('fe80::1%eth0'), 'fe80:0:0:0::/64');
assert.equal(ipKey('quatsch'), 'unbekannt');
assert.equal(ipKey(undefined), 'unbekannt');
});
test('sanitizeName entschärft Dateinamen', () => {
assert.equal(sanitizeName('urlaub.jpg'), 'urlaub.jpg');
assert.equal(sanitizeName('../../etc/passwd'), 'passwd');
assert.equal(sanitizeName('C:\\Users\\x\\bild.png'), 'bild.png');
assert.equal(sanitizeName(' a\tb\n.txt '), 'a b .txt');
assert.equal(sanitizeName('zeile\u0000null.txt'), 'zeilenull.txt');
assert.equal(sanitizeName('rechnung\u202Efdp.exe'), 'rechnungfdp.exe'); // versteckte Richtungsumkehr
assert.equal(sanitizeName(''), 'datei');
assert.equal(sanitizeName('..'), 'datei');
assert.equal(sanitizeName('ordner/'), 'datei');
assert.equal(sanitizeName('Ä-ö-ü ß.pdf'), 'Ä-ö-ü ß.pdf');
assert.equal(sanitizeName('a\u0308.txt'), 'ä.txt'); // zusammengesetzt -> ein Zeichen
assert.equal(sanitizeName('kaputt\ud800.txt'), 'kaputt\ufffd.txt');
const long = sanitizeName(`${'ä'.repeat(400)}.tar.gz`);
assert.ok(Buffer.byteLength(long) <= 200);
assert.ok(long.endsWith('.gz'));
assert.ok(Buffer.byteLength(sanitizeName('x'.repeat(1000))) <= 200);
});
test('contentDisposition kodiert Sonderzeichen sicher', () => {
assert.equal(contentDisposition('bild.png'), `attachment; filename="bild.png"; filename*=UTF-8''bild.png`);
assert.equal(
contentDisposition('Über "uns" (1).pdf'),
`attachment; filename="_ber _uns_ (1).pdf"; filename*=UTF-8''%C3%9Cber%20%22uns%22%20%281%29.pdf`,
);
// Kein Zeilenumbruch und kein Anführungszeichen darf den Header aufbrechen.
const header = contentDisposition('a"\r\nSet-Cookie: x=1');
assert.equal(/[\r\n]/.test(header), false);
assert.equal(header.split('"').length, 3);
});
test('RateLimiter sperrt nach dem Limit und gibt nach Ablauf wieder frei', () => {
const limiter = new RateLimiter({ limit: 3, windowMs: 1000 });
const t0 = 1_000_000;
assert.equal(limiter.take('a', t0), true);
assert.equal(limiter.take('a', t0 + 1), true);
assert.equal(limiter.take('a', t0 + 2), true);
assert.equal(limiter.take('a', t0 + 3), false);
assert.equal(limiter.blocked('a', t0 + 3), true);
assert.equal(limiter.blocked('b', t0 + 3), false);
assert.equal(limiter.retryAfter('a', t0 + 500), 1);
assert.equal(limiter.blocked('a', t0 + 1000), false);
assert.equal(limiter.take('a', t0 + 1000), true);
});
test('RateLimiter wächst nicht unbegrenzt', () => {
const limiter = new RateLimiter({ limit: 1, windowMs: 60_000, maxKeys: 100 });
for (let i = 0; i < 1000; i++) limiter.hit(`key${i}`, 1000);
// Der jüngste Schlüssel ist noch bekannt, die ältesten wurden verdrängt.
assert.equal(limiter.blocked('key999', 1000), true);
assert.equal(limiter.blocked('key0', 1000), false);
});