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:
1 parent
51ff6f9d40
commit
278194b707
31 files changed
+5099
No files matched your search
@@ -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 & <Seite>'), '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
@@ -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));
|
||||
@@ -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);
|
||||
});
|
||||
Reference in new issue
Block a user