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

+13
View File
@@ -0,0 +1,13 @@
# Alles, was nicht ins Image gehört
.git
.gitignore
.claude
.env
.env.example
data
test
node_modules
Dockerfile
compose.yaml
.dockerignore
*.md
+50
View File
@@ -0,0 +1,50 @@
# Einstellungen für den Dateitransfer.
# Diese Datei nach ".env" kopieren und anpassen. Die .env bleibt außerhalb des
# Repositorys (siehe .gitignore), weil die Upload-Codes darin stehen.
# --- Upload-Codes -----------------------------------------------------------
# Wer hochladen will, braucht einen dieser Codes. Schreibweise: name:code,
# mehrere durch Komma getrennt. Der Name erscheint nur im Protokoll, damit du
# siehst, mit welchem Code etwas hochgeladen wurde. Einen Code nimmst du zurück,
# indem du ihn hier löschst und den Dienst neu startest.
# Codes: mindestens 8 Zeichen, am besten nur Buchstaben, Ziffern und Bindestriche.
# Ohne Eintrag ist das Hochladen gesperrt.
# Beispiel: UPLOAD_CODES=freunde:hier-einen-eigenen-code,familie:noch-ein-code
UPLOAD_CODES=
# Jeder darf ohne Code hochladen (nicht empfohlen):
# OPEN_UPLOADS=1
# --- Grenzen ----------------------------------------------------------------
# Größte Gesamtgröße eines Transfers
MAX_TRANSFER_SIZE=5GB
# Höchstzahl an Dateien je Transfer
MAX_FILES=200
# So viel Platz dürfen alle Transfers zusammen belegen
STORAGE_QUOTA=50GB
# So viel Platz muss auf der Festplatte immer frei bleiben
MIN_FREE_SPACE=5GB
# Wählbare Fristen in Tagen und die Vorauswahl
EXPIRY_DAYS=1,7,30
DEFAULT_EXPIRY_DAYS=7
# --- Betrieb ----------------------------------------------------------------
# Name oben links auf der Seite
SITE_NAME=shiuuji.de
# Adresse und Port, auf denen der Dienst lauscht
HOST=127.0.0.1
PORT=8083
# Ordner für die hochgeladenen Dateien
DATA_DIR=data
# Auf 1 setzen, wenn ein Reverse-Proxy (z. B. Caddy) davorsteht. Dann nimmt
# der Dienst die Besucher-Adresse aus dem Header X-Forwarded-For.
TRUST_PROXY=0
# Nur zum Entwickeln: Seiten und Skripte bei jedem Aufruf neu von der Platte lesen
# DEV=1
# --- Nur für Docker (compose.yaml) -------------------------------------------
# Im Container sind HOST, PORT, DATA_DIR und TRUST_PROXY fest vorgegeben; die
# Werte oben gelten dort nicht. Nötig sind dafür die Nummern des Benutzers, dem
# der Ordner "data" gehört (Ausgabe von: id filetransfer):
# APP_UID=
# APP_GID=
+4
View File
@@ -0,0 +1,4 @@
# Hochgeladene Dateien und persönliche Einstellungen gehören nicht ins Repository
/data/
.env
node_modules/
+26
View File
@@ -0,0 +1,26 @@
# Dateitransfer. Kommt ohne npm-Pakete aus, deshalb gibt es keinen Bau-Schritt:
# Das Image enthält nur Node.js und die Dateien dieses Repositorys.
FROM node:26-alpine
ENV NODE_ENV=production \
HOST=0.0.0.0 \
PORT=8080 \
DATA_DIR=/data
WORKDIR /app
COPY package.json server.js ./
COPY src ./src
COPY pages ./pages
COPY public ./public
COPY tools ./tools
# Hochgeladene Dateien liegen außerhalb des Images in einem eingehängten Ordner.
RUN mkdir /data && chown node:node /data
USER node
VOLUME /data
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
CMD ["node", "-e", "fetch('http://127.0.0.1:' + process.env.PORT + '/healthz').then((r) => process.exit(r.ok ? 0 : 1), () => process.exit(1))"]
CMD ["node", "server.js"]
+158
View File
@@ -1,2 +1,160 @@
# FileTransfer # FileTransfer
Kleiner, privater Dateitransfer: Dateien hochladen, einen kurzen Link bekommen,
weitergeben – wer den Link kennt, kann die Dateien herunterladen. Nach Ablauf
der gewählten Frist löscht der Server sie von selbst.
- Hochladen nur mit **Upload-Code**, Herunterladen ohne Anmeldung über den Link
- Mehrere Dateien je Link, Frist wählbar (Vorgabe: 1, 7 oder 30 Tage)
- Große Dateien werden in Stücken übertragen; reißt die Verbindung ab, macht
der Browser an derselben Stelle weiter
- Oberfläche auf Deutsch und Englisch, hell oder dunkel je nach Gerät
- Keine Cookies, keine Analyse, nichts von fremden Servern
- Node.js ohne zusätzliche Pakete – es gibt nichts zu installieren und nichts zu bauen
## Lokal ausprobieren
Voraussetzung: Node.js ab Version 22.
```
cp .env.example .env
```
In der `.env` bei `UPLOAD_CODES` einen Code eintragen, dann:
```
npm start
```
Die Seite läuft danach unter http://localhost:8083. Mit `npm run dev` startet
der Dienst bei Änderungen am Code neu und liest Seiten und Skripte bei jedem
Aufruf frisch von der Platte.
## Einstellungen
Alle Einstellungen sind Umgebungsvariablen; liegt neben `server.js` eine Datei
`.env`, wird sie gelesen. Die vollständige Liste mit Erklärungen steht in
[.env.example](.env.example). Die wichtigsten:
| Variable | Vorgabe | Bedeutung |
|---------------------|--------------|---------------------------------------------------------|
| `UPLOAD_CODES` | leer | `name:code`, mehrere durch Komma getrennt. Leer = Hochladen gesperrt |
| `MAX_TRANSFER_SIZE` | `5GB` | größte Gesamtgröße eines Transfers |
| `STORAGE_QUOTA` | `50GB` | so viel dürfen alle Transfers zusammen belegen |
| `MIN_FREE_SPACE` | `5GB` | so viel muss auf der Platte frei bleiben |
| `EXPIRY_DAYS` | `1,7,30` | wählbare Fristen in Tagen |
| `SITE_NAME` | `shiuuji.de` | Name oben links auf der Seite |
| `TRUST_PROXY` | `0` | `1`, wenn ein Reverse-Proxy davorsteht |
Einen Upload-Code nimmst du zurück, indem du ihn aus `UPLOAD_CODES` löschst und
den Dienst neu startest. Bereits hochgeladene Dateien bleiben bis zu ihrer Frist.
## Betrieb auf dem Server (Docker)
Der Dienst läuft als Container und ist nur auf dem Server selbst unter
`127.0.0.1:8083` erreichbar. Nach außen gehört ein Reverse-Proxy mit HTTPS
davor (zum Beispiel Caddy), der Anfragen an diesen Port weiterreicht.
Einmalig einrichten, im Ordner des Repositorys:
1. Eigenen Benutzer für den Dienst anlegen und den Datenordner erstellen:
```
sudo useradd --system --no-create-home --shell /usr/sbin/nologin filetransfer
sudo install -d -o filetransfer -g filetransfer -m 700 data
```
2. `.env` aus der Vorlage erstellen und nur für root lesbar machen:
```
sudo cp .env.example .env
sudo chmod 600 .env
```
3. In der `.env` die Upload-Codes eintragen und am Ende zwei Zeilen mit den
Nummern des neuen Benutzers ergänzen (Ausgabe von `id filetransfer`):
```
APP_UID=<uid>
APP_GID=<gid>
```
4. Starten:
```
sudo docker compose up -d --build
```
Später:
| Zweck | Befehl |
|--------------------------------|-------------------------------------------------------------------|
| Status | `sudo docker compose ps` |
| Protokoll | `sudo docker compose logs --tail 50` |
| Neue Version einspielen | `sudo git pull && sudo docker compose up -d --build` |
| Node.js im Image aktualisieren | `sudo docker compose build --pull && sudo docker compose up -d` |
| Transfers auflisten | `sudo docker compose exec filetransfer node tools/transfers.js list` |
| Einen Transfer löschen | `sudo docker compose exec filetransfer node tools/transfers.js delete <kennung>` |
Die Kennung sind die zehn Zeichen hinter `/d/` im Link. Im Protokoll steht zu
jedem Transfer, mit welchem Upload-Code (Name) er angelegt wurde.
Hinweise für den Reverse-Proxy: Anfragen dürfen nicht zwischengespeichert
(gepuffert) werden und müssen Körper bis 8 MB durchlassen – so groß ist ein
Stück beim Hochladen. Caddy macht beides von Haus aus richtig.
## Wie es funktioniert
```
server.js Start: Einstellungen lesen, Dienst hochfahren
src/config.js Einstellungen aus Umgebungsvariablen
src/app.js HTTP-Server, Routen, Schutz-Header
src/store.js Ablage der Transfers auf der Platte, Aufräumen
src/limiter.js Zugriffsbegrenzung je Adresse
src/pages.js lädt pages/ und public/ in den Arbeitsspeicher
pages/ HTML-Seiten (beide Sprachen stehen im selben Dokument)
public/ Gestaltung und Skripte für den Browser
tools/transfers.js Auflisten und Löschen von der Kommandozeile
test/ automatische Tests (npm test)
```
Ein Transfer liegt unter `data/transfers/<kennung>/`: die Dateien nach Position
benannt (`0`, `1`, …) und daneben `meta.json` mit Namen, Größen und Frist. Die
Dateinamen der Nutzer werden nie als Pfad verwendet.
Ablauf eines Uploads:
1. `POST /api/transfers` mit Upload-Code und Dateiliste legt den Transfer an und
liefert ein Upload-Token und ein Lösch-Token.
2. `PUT /api/transfers/<kennung>/files/<nr>?offset=<n>` überträgt die Dateien in
Stücken von 8 MB. Der Server nimmt ein Stück nur an, wenn es genau an das
bisher Empfangene anschließt; deshalb lässt sich jedes Stück gefahrlos
wiederholen.
3. `POST /api/transfers/<kennung>/finish` schließt ab. Erst jetzt ist der Link
gültig und die Frist beginnt.
Das Lösch-Token merkt sich der Browser, damit man eigene Transfers auf der
Startseite unter „Zuletzt hochgeladen“ vorzeitig löschen kann.
## Sicherheit
- Upload-Codes werden zeitunabhängig verglichen; nach 10 falschen Versuchen ist
eine Adresse für 10 Minuten gesperrt. Auch das Durchprobieren von Links wird
gebremst.
- Kennungen sind 10 zufällige Zeichen (rund 8 × 10¹⁴ Möglichkeiten). Wer den
Link hat, hat Zugriff – Links also nur an die richtigen Leute geben.
- Hochgeladene Dateien werden ausschließlich als Download ausgeliefert
(`Content-Disposition: attachment`, `nosniff`, eigene Content-Security-Policy),
nie als Seite im Browser ausgeführt.
- Die Dateien liegen unverschlüsselt auf dem Server. Wer Zugriff auf den Server
hat, kann sie lesen.
- Im Protokoll stehen keine IP-Adressen und keine Dateinamen.
## Tests
```
npm test
```
Die Tests starten den Dienst mit einem eigenen, leeren Datenordner im
Temp-Verzeichnis und räumen ihn danach wieder weg.
+35
View File
@@ -0,0 +1,35 @@
# Dateitransfer als Docker-Dienst.
#
# Starten / nach Änderungen neu bauen: sudo docker compose up -d --build
# Protokoll ansehen: sudo docker compose logs --tail 50
#
# Einstellungen (Upload-Codes, Grenzen) stehen in der Datei .env daneben,
# siehe .env.example. Erreichbar ist der Dienst nur auf dem Server selbst
# unter http://127.0.0.1:8083 – nach außen geht es über den Reverse-Proxy.
services:
filetransfer:
build: .
image: filetransfer:local
container_name: filetransfer
restart: unless-stopped
init: true
# Benutzer, dem der Ordner ./data gehört (APP_UID und APP_GID in der .env)
user: "${APP_UID:-1000}:${APP_GID:-1000}"
env_file: .env
environment:
# Diese Werte gelten im Container immer, egal was in der .env steht.
HOST: 0.0.0.0
PORT: "8080"
DATA_DIR: /data
TRUST_PROXY: "1"
TZ: Europe/Berlin
ports:
- "127.0.0.1:8083:8080"
volumes:
- ./data:/data
# Der Dienst braucht außer dem Datenordner keine Schreibrechte.
read_only: true
cap_drop:
- ALL
security_opt:
- no-new-privileges:true
+15
View File
@@ -0,0 +1,15 @@
{
"name": "filetransfer",
"version": "1.0.0",
"private": true,
"description": "Kleiner Dateitransfer: hochladen, kurzen Link weitergeben, herunterladen.",
"type": "module",
"engines": {
"node": ">=22"
},
"scripts": {
"start": "node server.js",
"dev": "DEV=1 node --watch server.js",
"test": "node --test \"test/*.test.js\""
}
}
+30
View File
@@ -0,0 +1,30 @@
<!doctype html>
<html lang="de" data-title-de="Seite nicht gefunden" data-title-en="Page not found">
<head>
{{head}}
<title>Seite nicht gefunden – {{siteName}}</title>
</head>
<body>
{{header}}
<main class="container">
<section class="intro">
<h1>
<span lang="de">Seite nicht gefunden</span>
<span lang="en">Page not found</span>
</h1>
<p class="lead">
<span lang="de">Unter dieser Adresse gibt es nichts.</span>
<span lang="en">There is nothing at this address.</span>
</p>
<p>
<a class="button button-secondary" href="/">
<span lang="de">Zur Startseite</span>
<span lang="en">Go to the start page</span>
</a>
</p>
</section>
</main>
{{footer}}
<script type="module" src="/js/common.js"></script>
</body>
</html>
+72
View File
@@ -0,0 +1,72 @@
<!doctype html>
<html lang="de" data-state="{{transferState}}" data-title-de="Dateien herunterladen" data-title-en="Download files">
<head>
{{head}}
<title>Dateien herunterladen – {{siteName}}</title>
</head>
<body>
{{header}}
<main class="container">
<!-- Welcher Abschnitt sichtbar ist, bestimmt data-state am <html>-Element. -->
<section class="intro" id="dl-loading">
<p class="lead">
<span lang="de">Wird geladen …</span>
<span lang="en">Loading …</span>
</p>
<noscript>
<p class="notice notice-warn">
<span lang="de">Zum Anzeigen der Dateien muss JavaScript im Browser eingeschaltet sein.</span>
<span lang="en">Showing the files needs JavaScript to be enabled in your browser.</span>
</p>
</noscript>
</section>
<section id="dl-ready">
<div class="intro">
<h1 id="dl-title"></h1>
<p class="lead" id="dl-meta"></p>
</div>
<div class="card card-flush">
<ul class="file-list file-list-plain" id="dl-list"></ul>
</div>
<p class="hint hint-below">
<span lang="de">Öffne Dateien nur, wenn du der Person vertraust, die dir den Link geschickt hat.</span>
<span lang="en">Only open files if you trust the person who sent you the link.</span>
</p>
</section>
<section class="intro" id="dl-missing">
<h1>
<span lang="de">Diesen Link gibt es nicht mehr</span>
<span lang="en">This link no longer exists</span>
</h1>
<p class="lead">
<span lang="de">Die Dateien sind abgelaufen oder wurden gelöscht. Vielleicht wurde der Link auch nicht vollständig kopiert.</span>
<span lang="en">The files have expired or were deleted. The link may also have been copied incompletely.</span>
</p>
<p>
<a class="button button-secondary" href="/">
<span lang="de">Zur Startseite</span>
<span lang="en">Go to the start page</span>
</a>
</p>
</section>
<section class="intro" id="dl-error">
<h1>
<span lang="de">Das hat nicht geklappt</span>
<span lang="en">That did not work</span>
</h1>
<p class="lead" id="dl-error-text"></p>
<p>
<button type="button" class="button button-secondary" id="dl-retry">
<span lang="de">Erneut versuchen</span>
<span lang="en">Try again</span>
</button>
</p>
</section>
</main>
{{footer}}
<script type="module" src="/js/download.js"></script>
</body>
</html>
+187
View File
@@ -0,0 +1,187 @@
<!doctype html>
<html lang="de" data-title-de="Dateien teilen" data-title-en="Share files">
<head>
{{head}}
<title>Dateien teilen – {{siteName}}</title>
</head>
<body>
{{header}}
<main class="container">
<section class="intro">
<h1>
<span lang="de">Dateien teilen</span>
<span lang="en">Share files</span>
</h1>
<p class="lead">
<span lang="de">Lade Dateien hoch und gib den Link weiter. Nach Ablauf der Frist werden sie automatisch gelöscht.</span>
<span lang="en">Upload files and pass on the link. They are deleted automatically once the time is up.</span>
</p>
</section>
<noscript>
<p class="notice notice-warn">
<span lang="de">Zum Hochladen muss JavaScript im Browser eingeschaltet sein.</span>
<span lang="en">Uploading needs JavaScript to be enabled in your browser.</span>
</p>
</noscript>
<section class="card" id="uploader">
<!-- Schritt 1: Dateien auswählen -->
<form id="step-select" novalidate>
<div class="dropzone" id="dropzone">
<svg class="dropzone-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
<path d="M12 16V4"/>
<path d="m7 9 5-5 5 5"/>
<path d="M5 16v2a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2v-2"/>
</svg>
<p class="dropzone-title">
<span lang="de">Dateien hierher ziehen</span>
<span lang="en">Drag files here</span>
</p>
<p class="dropzone-or">
<span lang="de">oder</span>
<span lang="en">or</span>
</p>
<input class="visually-hidden" type="file" id="file-input" multiple>
<label class="button button-secondary" for="file-input">
<span lang="de">Dateien auswählen</span>
<span lang="en">Choose files</span>
</label>
<p class="hint" id="limit-hint"></p>
</div>
<div id="selection" hidden>
<ul class="file-list" id="file-list"></ul>
<div class="selection-summary">
<span id="selection-total"></span>
<button type="button" class="link-button" id="clear-files">
<span lang="de">Alle entfernen</span>
<span lang="en">Remove all</span>
</button>
</div>
</div>
<div class="fields">
<div class="field">
<label for="expiry">
<span lang="de">Verfügbar für</span>
<span lang="en">Available for</span>
</label>
<select id="expiry"></select>
</div>
<div class="field" id="code-field">
<label for="code">
<span lang="de">Upload-Code</span>
<span lang="en">Upload code</span>
</label>
<input type="text" id="code" autocomplete="off" autocapitalize="none" autocorrect="off" spellcheck="false" maxlength="200">
<label class="check">
<input type="checkbox" id="remember-code">
<span lang="de">Auf diesem Gerät merken</span>
<span lang="en">Remember on this device</span>
</label>
</div>
</div>
<p class="hint" id="code-hint">
<span lang="de">Zum Hochladen brauchst du einen Upload-Code. Du bekommst ihn von der Person, die diese Seite betreibt.</span>
<span lang="en">You need an upload code to upload. Ask the person who runs this site for one.</span>
</p>
<p class="notice notice-error" id="form-error" role="alert" hidden></p>
<button type="submit" class="button button-primary button-wide" id="start-upload" disabled>
<span lang="de">Hochladen</span>
<span lang="en">Upload</span>
</button>
</form>
<!-- Schritt 2: Fortschritt -->
<div id="step-progress" hidden>
<h2 class="card-title" id="progress-title" tabindex="-1">
<span lang="de">Wird hochgeladen …</span>
<span lang="en">Uploading …</span>
</h2>
<progress id="progress-bar" max="1000" value="0" aria-labelledby="progress-title"></progress>
<p class="progress-line">
<strong id="progress-percent">0 %</strong>
<span id="progress-detail"></span>
</p>
<p class="hint" id="progress-file"></p>
<p class="notice notice-warn" id="progress-retry" role="status" hidden>
<span lang="de">Verbindung unterbrochen – der Upload wird gleich fortgesetzt …</span>
<span lang="en">Connection interrupted – the upload will continue in a moment …</span>
</p>
<div class="actions">
<button type="button" class="button button-secondary" id="cancel-upload">
<span lang="de">Abbrechen</span>
<span lang="en">Cancel</span>
</button>
</div>
</div>
<!-- Schritt 3: fertig -->
<div id="step-done" hidden>
<div class="done-head">
<svg class="done-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
<path d="m5 12.5 4.5 4.5L19 7.5"/>
</svg>
<h2 class="card-title" id="done-title" tabindex="-1">
<span lang="de">Fertig – hier ist dein Link</span>
<span lang="en">Done – here is your link</span>
</h2>
</div>
<div class="link-row">
<input type="text" id="share-link" readonly aria-labelledby="done-title">
<button type="button" class="button button-primary" id="copy-link"></button>
</div>
<p class="hint" id="done-info"></p>
<div class="actions">
<a class="button button-secondary" id="open-link" href="/">
<span lang="de">Link öffnen</span>
<span lang="en">Open link</span>
</a>
<button type="button" class="button button-secondary" id="new-upload">
<span lang="de">Weitere Dateien hochladen</span>
<span lang="en">Upload more files</span>
</button>
</div>
</div>
<!-- Upload unterbrochen -->
<div id="step-error" hidden>
<h2 class="card-title" id="error-title" tabindex="-1">
<span lang="de">Upload unterbrochen</span>
<span lang="en">Upload interrupted</span>
</h2>
<p class="notice notice-error" id="upload-error" role="alert"></p>
<p class="hint" id="error-progress"></p>
<div class="actions">
<button type="button" class="button button-primary" id="resume-upload">
<span lang="de">Fortsetzen</span>
<span lang="en">Resume</span>
</button>
<button type="button" class="button button-secondary" id="discard-upload">
<span lang="de">Verwerfen</span>
<span lang="en">Discard</span>
</button>
</div>
</div>
</section>
<section class="recent" id="recent" hidden>
<h2>
<span lang="de">Zuletzt hochgeladen</span>
<span lang="en">Recently uploaded</span>
</h2>
<p class="hint">
<span lang="de">Diese Liste liegt nur in diesem Browser.</span>
<span lang="en">This list is kept in this browser only.</span>
</p>
<ul class="recent-list" id="recent-list"></ul>
<p class="notice notice-error" id="recent-error" role="alert" hidden></p>
</section>
</main>
{{footer}}
<script type="module" src="/js/upload.js"></script>
</body>
</html>
+6
View File
@@ -0,0 +1,6 @@
<footer class="site-footer container">
<p>
<span lang="de">Privater Dateitransfer</span>
<span lang="en">Private file transfer</span>
</p>
</footer>
+11
View File
@@ -0,0 +1,11 @@
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="application-name" content="{{siteName}}">
<meta name="robots" content="noindex, nofollow">
<meta name="referrer" content="no-referrer">
<meta name="color-scheme" content="light dark">
<meta name="theme-color" media="(prefers-color-scheme: light)" content="#f5f4f1">
<meta name="theme-color" media="(prefers-color-scheme: dark)" content="#131619">
<link rel="icon" href="/favicon.svg" type="image/svg+xml">
<link rel="stylesheet" href="/css/style.css">
<script src="/js/lang.js"></script>
+7
View File
@@ -0,0 +1,7 @@
<header class="site-header container">
<a class="brand" href="/">{{siteName}}</a>
<div class="lang-switch" role="group" aria-label="Sprache / Language">
<button type="button" data-set-lang="de" aria-pressed="true" aria-label="Deutsch">DE</button>
<button type="button" data-set-lang="en" aria-pressed="false" aria-label="English">EN</button>
</div>
</header>
+754
View File
@@ -0,0 +1,754 @@
/* Dateitransfer – schlicht und ruhig, hell oder dunkel je nach Geräteeinstellung. */
:root {
color-scheme: light dark;
--bg: #f5f4f1;
--surface: #ffffff;
--surface-2: #faf9f7;
--text: #20242a;
--muted: #667085;
--border: #e4e1db;
--border-strong: #cdc9c1;
--accent: #2f6f6a;
--accent-hover: #275d59;
--accent-soft: #e7f0ef;
--on-accent: #ffffff;
--danger-soft: #fbeceb;
--danger-text: #8f1d17;
--warn-soft: #fdf3d7;
--warn-text: #6a4b00;
--shadow: 0 1px 2px rgb(24 28 36 / 4%), 0 10px 30px rgb(24 28 36 / 6%);
--radius: 16px;
--radius-sm: 10px;
--font: system-ui, -apple-system, "Segoe UI", Roboto, "Noto Sans", "Helvetica Neue", Arial, sans-serif;
--mono: ui-monospace, "SF Mono", "Cascadia Mono", "Roboto Mono", Menlo, Consolas, monospace;
}
@media (prefers-color-scheme: dark) {
:root {
--bg: #131619;
--surface: #1b1f23;
--surface-2: #171a1e;
--text: #e7e9ec;
--muted: #9aa4b2;
--border: #2a3036;
--border-strong: #3b434b;
--accent: #74c2b9;
--accent-hover: #8fd1c9;
--accent-soft: #1c2e2d;
--on-accent: #0c1d1b;
--danger-soft: #3a1f1d;
--danger-text: #ffb4ab;
--warn-soft: #362e14;
--warn-text: #f1dc9c;
--shadow: none;
}
}
/* ------------------------------------------------------------ Grundlagen */
*,
*::before,
*::after {
box-sizing: border-box;
}
html {
-webkit-text-size-adjust: 100%;
text-size-adjust: 100%;
/* Platz für die Bildlaufleiste freihalten, damit nichts springt. */
scrollbar-gutter: stable;
}
body {
display: flex;
flex-direction: column;
min-height: 100vh;
min-height: 100dvh;
margin: 0;
background: var(--bg);
color: var(--text);
font: 1.0625rem/1.55 var(--font);
-webkit-font-smoothing: antialiased;
}
[hidden] {
display: none !important;
}
/* Beide Sprachen stehen im HTML; sichtbar ist die am <html>-Element gesetzte. */
html[lang="de"] [lang="en"],
html[lang="en"] [lang="de"] {
display: none !important;
}
.visually-hidden {
position: absolute;
width: 1px;
height: 1px;
margin: -1px;
padding: 0;
overflow: hidden;
clip-path: inset(50%);
white-space: nowrap;
border: 0;
}
:focus-visible {
outline: 2px solid var(--accent);
outline-offset: 2px;
}
h1,
h2,
p {
margin: 0;
}
a {
color: var(--accent);
text-underline-offset: 0.18em;
}
.container {
width: min(100% - 2.5rem, 40rem);
margin-inline: auto;
}
main {
flex: 1;
padding-block: clamp(1.5rem, 7vh, 4.5rem) 3rem;
}
/* ------------------------------------------------------- Kopf und Fuß */
.site-header {
display: flex;
align-items: center;
justify-content: space-between;
gap: 1rem;
padding-block: 1.25rem;
}
.brand {
display: inline-flex;
align-items: center;
gap: 0.6rem;
color: inherit;
font-weight: 650;
letter-spacing: -0.01em;
text-decoration: none;
}
.brand::before {
content: "";
width: 0.7rem;
height: 0.7rem;
border-radius: 50%;
background: var(--accent);
}
.lang-switch {
display: inline-flex;
padding: 3px;
border: 1px solid var(--border);
border-radius: 999px;
background: var(--surface);
}
.lang-switch button {
padding: 0.3rem 0.7rem;
border: 0;
border-radius: 999px;
background: none;
color: var(--muted);
font: inherit;
font-size: 0.8rem;
font-weight: 650;
letter-spacing: 0.05em;
cursor: pointer;
}
.lang-switch button[aria-pressed="true"] {
background: var(--accent-soft);
color: var(--accent);
}
.site-footer {
padding-block: 1.5rem 2rem;
color: var(--muted);
font-size: 0.875rem;
text-align: center;
}
/* ----------------------------------------------------------- Texte */
.intro {
margin-bottom: 2rem;
}
h1 {
font-size: clamp(1.9rem, 1.4rem + 2.2vw, 2.5rem);
font-weight: 680;
line-height: 1.12;
letter-spacing: -0.025em;
overflow-wrap: anywhere;
}
.lead {
max-width: 34rem;
margin-top: 0.75rem;
color: var(--muted);
font-size: 1.1rem;
}
.intro .button {
margin-top: 1.5rem;
}
.hint {
color: var(--muted);
font-size: 0.9rem;
}
.hint-below {
margin-top: 1rem;
text-align: center;
}
/* ----------------------------------------------------------- Karte */
.card {
padding: clamp(1.1rem, 4vw, 1.75rem);
border: 1px solid var(--border);
border-radius: var(--radius);
background: var(--surface);
box-shadow: var(--shadow);
}
.card-flush {
padding: 0.35rem clamp(0.9rem, 3vw, 1.25rem);
}
.card-title {
font-size: 1.25rem;
font-weight: 650;
letter-spacing: -0.01em;
}
.card-title:focus {
outline: none;
}
/* --------------------------------------------------------- Knöpfe */
.button {
display: inline-flex;
align-items: center;
justify-content: center;
gap: 0.5rem;
min-height: 2.75rem;
padding: 0.6rem 1.15rem;
border: 1px solid transparent;
border-radius: var(--radius-sm);
font: inherit;
font-weight: 620;
line-height: 1.2;
text-align: center;
text-decoration: none;
cursor: pointer;
transition:
background-color 0.15s,
border-color 0.15s;
}
.button-primary {
background: var(--accent);
color: var(--on-accent);
}
.button-primary:hover:not(:disabled) {
background: var(--accent-hover);
}
.button-secondary {
border-color: var(--border-strong);
background: var(--surface);
color: var(--text);
}
.button-secondary:hover:not(:disabled) {
border-color: var(--muted);
}
.button-danger {
border-color: var(--danger-text);
background: var(--danger-soft);
color: var(--danger-text);
}
.button-small {
min-height: 2.25rem;
padding: 0.4rem 0.8rem;
font-size: 0.9rem;
}
.button-wide {
width: 100%;
margin-top: 1.5rem;
}
.button:disabled {
opacity: 0.45;
cursor: not-allowed;
}
/* Das versteckte Dateifeld gibt seinen Tastaturfokus an den Knopf weiter. */
.visually-hidden:focus-visible + .button {
outline: 2px solid var(--accent);
outline-offset: 2px;
}
.link-button {
padding: 0;
border: 0;
background: none;
color: var(--muted);
font: inherit;
font-size: 0.9rem;
text-decoration: underline;
text-underline-offset: 0.18em;
cursor: pointer;
}
.link-button:hover {
color: var(--text);
}
.icon-button {
display: inline-grid;
flex: none;
place-items: center;
width: 2rem;
height: 2rem;
padding: 0;
border: 0;
border-radius: 8px;
background: none;
color: var(--muted);
font: inherit;
font-size: 1.25rem;
line-height: 1;
cursor: pointer;
}
.icon-button:hover {
background: var(--surface-2);
color: var(--text);
}
.actions {
display: flex;
flex-wrap: wrap;
gap: 0.6rem;
margin-top: 1.5rem;
}
/* ------------------------------------------------------- Ablagefläche */
.dropzone {
display: grid;
justify-items: center;
padding: 2.25rem 1.25rem 1.6rem;
border: 1.5px dashed var(--border-strong);
border-radius: var(--radius);
background: var(--surface-2);
text-align: center;
transition:
background-color 0.15s,
border-color 0.15s;
}
.dropzone.is-dragover {
border-color: var(--accent);
background: var(--accent-soft);
}
.dropzone-icon {
width: 3rem;
height: 3rem;
margin-bottom: 0.9rem;
padding: 0.7rem;
border-radius: 50%;
background: var(--accent-soft);
color: var(--accent);
}
.dropzone-title {
font-size: 1.1rem;
font-weight: 620;
}
.dropzone-or {
margin: 0.15rem 0 0.7rem;
color: var(--muted);
font-size: 0.9rem;
}
.dropzone .hint {
margin-top: 1rem;
}
/* --------------------------------------------------------- Dateiliste */
.file-list {
margin: 1.25rem 0 0;
padding: 0;
border: 1px solid var(--border);
border-radius: var(--radius-sm);
list-style: none;
}
.file-list li {
display: flex;
align-items: center;
gap: 0.75rem;
min-height: 3rem;
padding: 0.4rem 0.5rem 0.4rem 0.9rem;
}
.file-list li + li {
border-top: 1px solid var(--border);
}
.file-list-plain {
margin: 0;
border: 0;
}
.file-list-plain li {
min-height: 3.75rem;
padding-inline: 0;
}
.file-name {
display: flex;
flex: 1;
min-width: 0;
}
.file-stem {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.file-ext {
flex: none;
white-space: nowrap;
}
.file-size {
flex: none;
color: var(--muted);
font-size: 0.9rem;
font-variant-numeric: tabular-nums;
white-space: nowrap;
}
.selection-summary {
display: flex;
align-items: baseline;
justify-content: space-between;
gap: 1rem;
margin-top: 0.6rem;
color: var(--muted);
font-size: 0.9rem;
}
/* ------------------------------------------------------------ Felder */
.fields {
display: grid;
gap: 1rem;
margin-top: 1.5rem;
}
@media (min-width: 34rem) {
.fields {
grid-template-columns: 1fr 1fr;
}
}
.field > label:first-child {
display: block;
margin-bottom: 0.35rem;
font-size: 0.9rem;
font-weight: 620;
}
input[type="text"],
select {
width: 100%;
min-height: 2.75rem;
padding: 0.55rem 0.75rem;
border: 1px solid var(--border-strong);
border-radius: var(--radius-sm);
background: var(--surface);
color: var(--text);
font: inherit;
}
input[type="text"]:focus-visible,
select:focus-visible {
outline-offset: 0;
border-color: var(--accent);
}
input[aria-invalid="true"] {
border-color: var(--danger-text);
}
.check {
display: inline-flex;
align-items: center;
gap: 0.45rem;
margin-top: 0.55rem;
color: var(--muted);
font-size: 0.9rem;
cursor: pointer;
}
.check input {
width: 1rem;
height: 1rem;
margin: 0;
accent-color: var(--accent);
}
#code-hint {
margin-top: 1rem;
}
.notice {
margin-top: 1rem;
padding: 0.7rem 0.9rem;
border-radius: var(--radius-sm);
font-size: 0.95rem;
}
.notice-error {
background: var(--danger-soft);
color: var(--danger-text);
}
.notice-warn {
background: var(--warn-soft);
color: var(--warn-text);
}
/* ------------------------------------------------------- Fortschritt */
progress {
display: block;
width: 100%;
height: 0.6rem;
margin-top: 1.25rem;
overflow: hidden;
border: 0;
border-radius: 999px;
background: var(--border);
appearance: none;
}
progress::-webkit-progress-bar {
border-radius: 999px;
background: var(--border);
}
progress::-webkit-progress-value {
border-radius: 999px;
background: var(--accent);
transition: width 0.25s linear;
}
progress::-moz-progress-bar {
border-radius: 999px;
background: var(--accent);
}
.progress-line {
display: flex;
flex-wrap: wrap;
align-items: baseline;
justify-content: space-between;
gap: 0.25rem 1rem;
margin-top: 0.7rem;
font-variant-numeric: tabular-nums;
}
.progress-line span {
color: var(--muted);
font-size: 0.95rem;
}
#progress-file {
margin-top: 0.35rem;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
/* ------------------------------------------------------------ Fertig */
.done-head {
display: flex;
align-items: center;
gap: 0.75rem;
}
.done-icon {
flex: none;
width: 2.25rem;
height: 2.25rem;
padding: 0.5rem;
border-radius: 50%;
background: var(--accent-soft);
color: var(--accent);
}
.link-row {
display: flex;
gap: 0.5rem;
margin-top: 1.25rem;
}
.link-row input {
flex: 1;
min-width: 0;
background: var(--surface-2);
font-family: var(--mono);
font-size: 0.95rem;
}
.link-row .button {
flex: none;
min-width: 7rem;
}
@media (max-width: 26rem) {
.link-row {
flex-direction: column;
}
}
#done-info,
#error-progress {
margin-top: 0.75rem;
}
/* ------------------------------------------------- Zuletzt hochgeladen */
.recent {
margin-top: 2.75rem;
}
.recent h2 {
font-size: 1.05rem;
font-weight: 650;
}
.recent-list {
margin: 0.9rem 0 0;
padding: 0;
list-style: none;
}
.recent-list li {
display: flex;
flex-wrap: wrap;
align-items: center;
gap: 0.5rem 1rem;
padding: 0.85rem 0;
border-top: 1px solid var(--border);
}
.recent-main {
flex: 1 1 14rem;
min-width: 0;
}
.recent-link {
display: flex;
min-width: 0;
color: var(--text);
font-weight: 620;
text-decoration: none;
}
.recent-link .file-name {
flex: 0 1 auto;
}
.recent-link:hover .file-stem {
text-decoration: underline;
text-underline-offset: 0.18em;
}
.recent-more {
flex: none;
margin-left: 0.4rem;
color: var(--muted);
font-weight: 400;
white-space: nowrap;
}
.recent-meta {
color: var(--muted);
font-size: 0.875rem;
}
.recent-actions {
display: flex;
flex: none;
gap: 0.5rem;
}
/* ---------------------------------------------------- Download-Seite */
#dl-loading,
#dl-ready,
#dl-missing,
#dl-error {
display: none;
}
html[data-state="loading"] #dl-loading,
html[data-state="ready"] #dl-ready,
html[data-state="missing"] #dl-missing,
html[data-state="error"] #dl-error {
display: block;
}
@media (max-width: 26rem) {
.file-list-plain li {
flex-wrap: wrap;
padding-block: 0.75rem;
}
.file-list-plain .file-name {
flex-basis: 100%;
}
.file-list-plain .file-size {
flex: 1;
}
}
@media (prefers-reduced-motion: reduce) {
* {
transition: none !important;
}
}
+4
View File
@@ -0,0 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
<rect width="64" height="64" rx="16" fill="#2f6f6a"/>
<path d="M32 45V21M21 31l11-11 11 11" fill="none" stroke="#fff" stroke-width="5.5" stroke-linecap="round" stroke-linejoin="round"/>
</svg>

After

Width:  |  Height:  |  Size: 258 B

+179
View File
@@ -0,0 +1,179 @@
// Gemeinsames für alle Seiten: Sprachumschalter, Formatierung, Aufrufe an den Server.
const root = document.documentElement;
const siteName = document.querySelector('meta[name="application-name"]')?.content ?? '';
// ---------------------------------------------------------------- Sprache
export function getLang() {
return root.lang === 'en' ? 'en' : 'de';
}
const listeners = new Set();
/** Meldet eine Funktion an, die nach einem Sprachwechsel neu zeichnet. */
export function onLangChange(fn) {
listeners.add(fn);
}
function applyLang() {
const lang = getLang();
for (const button of document.querySelectorAll('[data-set-lang]')) {
button.setAttribute('aria-pressed', String(button.dataset.setLang === lang));
}
const title = lang === 'en' ? root.dataset.titleEn : root.dataset.titleDe;
if (title) document.title = siteName ? `${title} – ${siteName}` : title;
}
export function setLang(lang) {
root.lang = lang === 'en' ? 'en' : 'de';
try {
localStorage.setItem('lang', root.lang);
} catch {
// Ohne Speicher gilt die Wahl nur für diese Seite.
}
applyLang();
for (const fn of listeners) fn(root.lang);
}
for (const button of document.querySelectorAll('[data-set-lang]')) {
button.addEventListener('click', () => setLang(button.dataset.setLang));
}
applyLang();
/** Setzt Platzhalter wie {name} in einen Text ein. */
export function fill(template, params = {}) {
return template.replace(/\{(\w+)\}/g, (match, key) => (key in params ? String(params[key]) : match));
}
// ----------------------------------------------------------- Formatierung
function locale() {
if (getLang() === 'de') return 'de-DE';
return /^en\b/i.test(navigator.language ?? '') ? navigator.language : 'en-GB';
}
const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
/** 1536 -> "1,5 KB" (1 KB = 1024 B, wie es der Server rechnet). */
export function formatBytes(bytes) {
let value = bytes;
let unit = 0;
const digits = () => (unit === 0 || value >= 100 ? 0 : 1);
while (unit < UNITS.length - 1 && Number(value.toFixed(digits())) >= 1024) {
value /= 1024;
unit += 1;
}
const number = new Intl.NumberFormat(locale(), { maximumFractionDigits: digits() }).format(value);
return `${number}\u00a0${UNITS[unit]}`;
}
export function formatDate(timestamp) {
return new Intl.DateTimeFormat(locale(), { dateStyle: 'long', timeStyle: 'short' }).format(new Date(timestamp));
}
/** Grobe Dauer für Restzeiten: "20 Sekunden", "3 Minuten", "1 Std. 10 Min.". */
export function formatDuration(seconds) {
const de = getLang() === 'de';
if (seconds < 50) {
const s = Math.max(5, Math.round(seconds / 5) * 5);
return de ? `${s} Sekunden` : `${s} seconds`;
}
const minutes = Math.round(seconds / 60);
if (minutes < 60) {
if (minutes === 1) return de ? '1 Minute' : '1 minute';
return de ? `${minutes} Minuten` : `${minutes} minutes`;
}
const hours = Math.floor(minutes / 60);
const rest = minutes % 60;
return de ? `${hours} Std. ${rest} Min.` : `${hours} h ${rest} min`;
}
/**
* Baut die Anzeige eines Dateinamens: Ist er zu lang, wird in der Mitte
* gekürzt, die Endung bleibt immer sichtbar.
*/
export function fileNameElement(name) {
const dot = name.lastIndexOf('.');
const hasExt = dot > 0 && name.length - dot <= 11;
const wrap = document.createElement('span');
wrap.className = 'file-name';
wrap.title = name;
const stem = document.createElement('span');
stem.className = 'file-stem';
stem.textContent = hasExt ? name.slice(0, dot) : name;
wrap.append(stem);
if (hasExt) {
const ext = document.createElement('span');
ext.className = 'file-ext';
ext.textContent = name.slice(dot);
wrap.append(ext);
}
return wrap;
}
// ------------------------------------------------------------------ Server
/** Fehler eines Aufrufs. status 0 heißt: Server gar nicht erreicht. */
export class ApiError extends Error {
constructor(status, body) {
super(body?.error ?? `http_${status}`);
this.name = 'ApiError';
this.status = status;
this.code = body?.error ?? null;
this.body = body ?? {};
}
}
export async function api(method, url, { json, token } = {}) {
const headers = {};
if (json !== undefined) headers['Content-Type'] = 'application/json';
if (token) headers.Authorization = `Bearer ${token}`;
let response;
try {
response = await fetch(url, {
method,
headers,
body: json === undefined ? undefined : JSON.stringify(json),
cache: 'no-store',
});
} catch {
throw new ApiError(0, { error: 'network' });
}
let body = null;
if (response.status !== 204) {
try {
body = await response.json();
} catch {
body = null;
}
}
if (!response.ok) throw new ApiError(response.status, body);
return body;
}
/** Kopiert Text in die Zwischenablage; gibt zurück, ob es geklappt hat. */
export async function copyText(text) {
try {
await navigator.clipboard.writeText(text);
return true;
} catch {
// Ältere Browser oder fehlende Berechtigung: klassischer Weg.
}
const area = document.createElement('textarea');
area.value = text;
area.readOnly = true;
area.className = 'visually-hidden';
document.body.append(area);
area.select();
let ok = false;
try {
ok = document.execCommand('copy');
} catch {
ok = false;
}
area.remove();
return ok;
}
+100
View File
@@ -0,0 +1,100 @@
// Download-Seite: zeigt die Dateien eines Transfers.
import { ApiError, api, fileNameElement, fill, formatBytes, formatDate, formatDuration, getLang, onLangChange } from './common.js';
const TEXT = {
de: {
title: (n) => (n === 1 ? '1 Datei zum Herunterladen' : `${n} Dateien zum Herunterladen`),
meta: '{size} · verfügbar bis {date}',
metaTotal: 'Zusammen {size} · verfügbar bis {date}',
download: 'Herunterladen',
downloadName: '„{name}“ herunterladen',
network: 'Der Server ist nicht erreichbar. Prüf bitte deine Internetverbindung.',
rateLimited: 'Zu viele Anfragen. Bitte warte {time} und versuch es dann noch einmal.',
generic: 'Die Dateiliste konnte nicht geladen werden (Fehler {code}).',
},
en: {
title: (n) => (n === 1 ? '1 file to download' : `${n} files to download`),
meta: '{size} · available until {date}',
metaTotal: '{size} in total · available until {date}',
download: 'Download',
downloadName: 'Download “{name}”',
network: 'The server cannot be reached. Please check your internet connection.',
rateLimited: 'Too many requests. Please wait {time} and try again.',
generic: 'The file list could not be loaded (error {code}).',
},
};
function t(key, params) {
const value = TEXT[getLang()][key];
return typeof value === 'function' ? value(params) : fill(value, params);
}
const root = document.documentElement;
const el = {
title: document.getElementById('dl-title'),
meta: document.getElementById('dl-meta'),
list: document.getElementById('dl-list'),
errorText: document.getElementById('dl-error-text'),
retry: document.getElementById('dl-retry'),
};
const id = (location.pathname.split('/')[2] ?? '').toLowerCase();
let transfer = null;
let failure = null;
function render() {
if (root.dataset.state === 'ready' && transfer) {
const count = transfer.files.length;
el.title.textContent = t('title', count);
el.meta.textContent = t(count === 1 ? 'meta' : 'metaTotal', {
size: formatBytes(transfer.totalBytes),
date: formatDate(transfer.expiresAt),
});
el.list.replaceChildren(
...transfer.files.map((file, index) => {
const item = document.createElement('li');
const size = document.createElement('span');
size.className = 'file-size';
size.textContent = formatBytes(file.size);
const link = document.createElement('a');
link.className = 'button button-secondary button-small';
link.href = `/d/${transfer.id}/${index}`;
link.download = file.name;
link.textContent = t('download');
link.setAttribute('aria-label', t('downloadName', { name: file.name }));
item.append(fileNameElement(file.name), size, link);
return item;
}),
);
} else if (root.dataset.state === 'error' && failure) {
if (failure instanceof ApiError && failure.status === 0) {
el.errorText.textContent = t('network');
} else if (failure instanceof ApiError && failure.status === 429) {
el.errorText.textContent = t('rateLimited', { time: formatDuration(Number(failure.body.retryAfter) || 60) });
} else {
el.errorText.textContent = t('generic', { code: failure?.code ?? failure?.status ?? '?' });
}
}
}
async function load() {
// Der Server hat schon mitgeteilt, dass es den Link nicht gibt.
if (root.dataset.state === 'missing') return;
root.dataset.state = 'loading';
try {
transfer = await api('GET', `/api/transfers/${encodeURIComponent(id)}`);
root.dataset.state = 'ready';
} catch (err) {
if (err instanceof ApiError && err.status === 404) {
root.dataset.state = 'missing';
} else {
failure = err;
root.dataset.state = 'error';
}
}
render();
}
el.retry.addEventListener('click', load);
onLangChange(render);
await load();
+15
View File
@@ -0,0 +1,15 @@
// Stellt die Sprache ein, bevor die Seite gezeichnet wird (deshalb ohne "defer"
// im <head>). Reihenfolge: gespeicherte Wahl, sonst Browsersprache, sonst Deutsch.
(function () {
var lang = null;
try {
lang = localStorage.getItem('lang');
} catch (e) {
// Speicher gesperrt (z. B. privates Fenster): dann entscheidet der Browser.
}
if (lang !== 'de' && lang !== 'en') {
var preferred = (navigator.languages && navigator.languages[0]) || navigator.language || 'de';
lang = /^de\b/i.test(preferred) ? 'de' : 'en';
}
document.documentElement.lang = lang;
})();
+983
View File
@@ -0,0 +1,983 @@
// Upload-Seite: Dateien auswählen, stückweise hochladen, Link anzeigen.
import {
ApiError,
api,
copyText,
fileNameElement,
fill,
formatBytes,
formatDate,
formatDuration,
getLang,
onLangChange,
} from './common.js';
const TEXT = {
de: {
days: (n) => (n === 1 ? '1 Tag' : `${n} Tage`),
files: (n) => (n === 1 ? '1 Datei' : `${n} Dateien`),
limitHint: 'Bis zu {size} pro Transfer',
remove: '„{name}“ entfernen',
tooLarge: 'Zusammen sind das {size} – erlaubt sind höchstens {max}.',
tooMany: 'Das sind {count} Dateien – erlaubt sind höchstens {max}.',
folderSkipped: 'Ordner lassen sich nicht hochladen. Pack sie vorher in eine ZIP-Datei.',
codeMissing: 'Bitte gib den Upload-Code ein.',
codeInvalid: 'Dieser Upload-Code stimmt nicht.',
rateLimited: 'Zu viele Versuche. Bitte warte {time} und versuch es dann noch einmal.',
storageFull: 'Auf dem Server ist gerade nicht genug Platz frei.',
uploadsDisabled: 'Das Hochladen ist auf dieser Seite gerade abgeschaltet.',
network: 'Der Server ist nicht erreichbar. Prüf bitte deine Internetverbindung.',
gone: 'Der angefangene Upload ist auf dem Server nicht mehr vorhanden. Bitte starte ihn neu.',
unreadable: '„{name}“ lässt sich nicht lesen. Wurde die Datei verschoben oder verändert?',
generic: 'Das hat nicht geklappt (Fehler {code}).',
progressDetail: '{done} von {total}',
eta: 'noch etwa {time}',
finishing: 'Wird abgeschlossen …',
currentFile: 'Datei {index} von {count}: {name}',
uploadedSoFar: 'Bisher hochgeladen: {done} von {total}',
doneInfo: '{files} · {size} · verfügbar bis {date}',
copy: 'Kopieren',
copied: 'Kopiert',
copyLink: 'Link kopieren',
more: (n) => (n === 1 ? '+ 1 weitere' : `+ ${n} weitere`),
recentMeta: '{size} · verfügbar bis {date}',
delete: 'Löschen',
confirmDelete: 'Wirklich löschen?',
deleteFailed: 'Löschen hat nicht geklappt. Versuch es später noch einmal.',
},
en: {
days: (n) => (n === 1 ? '1 day' : `${n} days`),
files: (n) => (n === 1 ? '1 file' : `${n} files`),
limitHint: 'Up to {size} per transfer',
remove: 'Remove “{name}”',
tooLarge: 'That is {size} in total – the limit is {max}.',
tooMany: 'That is {count} files – the limit is {max}.',
folderSkipped: 'Folders cannot be uploaded. Put them into a ZIP file first.',
codeMissing: 'Please enter the upload code.',
codeInvalid: 'This upload code is not correct.',
rateLimited: 'Too many attempts. Please wait {time} and try again.',
storageFull: 'There is not enough free space on the server right now.',
uploadsDisabled: 'Uploading is switched off on this site at the moment.',
network: 'The server cannot be reached. Please check your internet connection.',
gone: 'The upload you started no longer exists on the server. Please start it again.',
unreadable: '“{name}” cannot be read. Was the file moved or changed?',
generic: 'That did not work (error {code}).',
progressDetail: '{done} of {total}',
eta: 'about {time} left',
finishing: 'Finishing …',
currentFile: 'File {index} of {count}: {name}',
uploadedSoFar: 'Uploaded so far: {done} of {total}',
doneInfo: '{files} · {size} · available until {date}',
copy: 'Copy',
copied: 'Copied',
copyLink: 'Copy link',
more: (n) => `+ ${n} more`,
recentMeta: '{size} · available until {date}',
delete: 'Delete',
confirmDelete: 'Really delete?',
deleteFailed: 'Deleting did not work. Please try again later.',
},
};
/** Text in der aktuellen Sprache; Funktionen werden mit `params` aufgerufen. */
function t(key, params) {
const value = TEXT[getLang()][key];
return typeof value === 'function' ? value(params) : fill(value, params);
}
const $ = (id) => document.getElementById(id);
const el = {
stepSelect: $('step-select'),
stepProgress: $('step-progress'),
stepDone: $('step-done'),
stepError: $('step-error'),
dropzone: $('dropzone'),
fileInput: $('file-input'),
limitHint: $('limit-hint'),
selection: $('selection'),
fileList: $('file-list'),
selectionTotal: $('selection-total'),
clearFiles: $('clear-files'),
expiry: $('expiry'),
codeField: $('code-field'),
code: $('code'),
rememberCode: $('remember-code'),
codeHint: $('code-hint'),
formError: $('form-error'),
start: $('start-upload'),
progressTitle: $('progress-title'),
progressBar: $('progress-bar'),
progressPercent: $('progress-percent'),
progressDetail: $('progress-detail'),
progressFile: $('progress-file'),
progressRetry: $('progress-retry'),
cancel: $('cancel-upload'),
doneTitle: $('done-title'),
shareLink: $('share-link'),
copyLink: $('copy-link'),
doneInfo: $('done-info'),
openLink: $('open-link'),
newUpload: $('new-upload'),
errorTitle: $('error-title'),
uploadError: $('upload-error'),
errorProgress: $('error-progress'),
resume: $('resume-upload'),
discard: $('discard-upload'),
recent: $('recent'),
recentList: $('recent-list'),
recentError: $('recent-error'),
};
const ID_PATTERN = /^[2-9a-hjkmnp-z]{10}$/;
const MAX_ATTEMPTS = 8; // Versuche je Stück, bevor der Upload als unterbrochen gilt
const STALL_MS = 90_000; // so lange darf sich bei einem Stück nichts bewegen
const CANCELLED = Symbol('abgebrochen');
const state = {
config: null, // Grenzen und Fristen vom Server
files: [], // ausgewählte File-Objekte
phase: 'select', // select | uploading | finishing | done | error
formError: null, // { key, params } – Meldung im Formular
job: null, // laufender Upload
result: null, // fertiger Transfer
copiedUntil: 0,
deleteArmed: null, // Kennung, bei der „Löschen“ gerade nachfragt
recentError: null, // { key } – Meldung unter der Liste
};
// ------------------------------------------------------------- Speicher
function storageGet(storage, key) {
try {
return storage.getItem(key);
} catch {
return null;
}
}
function storageSet(storage, key, value) {
try {
if (value === null) storage.removeItem(key);
else storage.setItem(key, value);
} catch {
// Speicher gesperrt oder voll: dann eben ohne.
}
}
function loadRecent() {
let list;
try {
list = JSON.parse(storageGet(localStorage, 'uploads') ?? '[]');
} catch {
list = [];
}
if (!Array.isArray(list)) return [];
const now = Date.now();
return list.filter(
(item) =>
item &&
typeof item.id === 'string' &&
ID_PATTERN.test(item.id) &&
typeof item.deleteToken === 'string' &&
typeof item.name === 'string' &&
Number.isFinite(item.expiresAt) &&
item.expiresAt > now &&
Number.isFinite(item.count) &&
Number.isFinite(item.bytes),
);
}
function saveRecent(list) {
storageSet(localStorage, 'uploads', JSON.stringify(list.slice(0, 20)));
}
function rememberCode(code) {
if (el.rememberCode.checked) {
storageSet(localStorage, 'uploadCode', code);
storageSet(sessionStorage, 'uploadCode', null);
} else {
storageSet(localStorage, 'uploadCode', null);
storageSet(sessionStorage, 'uploadCode', code);
}
}
function forgetCode() {
storageSet(localStorage, 'uploadCode', null);
storageSet(sessionStorage, 'uploadCode', null);
}
// ------------------------------------------------------------ Auswahl
function totalBytes(files) {
return files.reduce((sum, file) => sum + file.size, 0);
}
/** Prüft die Auswahl gegen die Grenzen des Servers. */
function selectionProblem() {
const cfg = state.config;
if (!cfg || state.files.length === 0) return null;
if (state.files.length > cfg.maxFiles) {
return { key: 'tooMany', params: { count: state.files.length, max: cfg.maxFiles } };
}
const total = totalBytes(state.files);
if (total > cfg.maxTransferBytes) {
return { key: 'tooLarge', params: { size: formatBytes(total), max: formatBytes(cfg.maxTransferBytes) } };
}
return null;
}
function addFiles(list, { skippedFolder = false } = {}) {
const known = new Set(state.files.map((f) => `${f.name}\n${f.size}\n${f.lastModified}`));
for (const file of list) {
const key = `${file.name}\n${file.size}\n${file.lastModified}`;
if (known.has(key)) continue;
known.add(key);
state.files.push(file);
}
state.formError = skippedFolder ? { key: 'folderSkipped' } : null;
render();
}
/** Liest die Dateien aus einem Drag-and-drop; Ordner werden ausgelassen. */
function filesFromDrop(dataTransfer) {
const files = [];
let skippedFolder = false;
if (dataTransfer.items && dataTransfer.items.length > 0) {
for (const item of dataTransfer.items) {
if (item.kind !== 'file') continue;
if (item.webkitGetAsEntry?.()?.isDirectory) {
skippedFolder = true;
continue;
}
const file = item.getAsFile();
if (file) files.push(file);
}
} else {
files.push(...dataTransfer.files);
}
return { files, skippedFolder };
}
// ------------------------------------------------------------- Zeichnen
function show(step) {
for (const [name, node] of [
['select', el.stepSelect],
['progress', el.stepProgress],
['done', el.stepDone],
['error', el.stepError],
]) {
node.hidden = name !== step;
}
}
function renderSelect() {
const cfg = state.config;
el.limitHint.textContent = cfg ? t('limitHint', { size: formatBytes(cfg.maxTransferBytes) }) : '';
// Fristen: Auswahl beim Neuzeichnen behalten
if (cfg) {
const chosen = Number(el.expiry.value) || cfg.defaultExpiryDays;
el.expiry.replaceChildren(
...cfg.expiryDays.map((days) => {
const option = document.createElement('option');
option.value = String(days);
option.textContent = t('days', days);
option.selected = days === chosen;
return option;
}),
);
}
const codeNeeded = !cfg || cfg.codeRequired;
el.codeField.hidden = !codeNeeded;
el.codeHint.hidden = !codeNeeded;
el.selection.hidden = state.files.length === 0;
el.fileList.replaceChildren(
...state.files.map((file, index) => {
const item = document.createElement('li');
const size = document.createElement('span');
size.className = 'file-size';
size.textContent = formatBytes(file.size);
const remove = document.createElement('button');
remove.type = 'button';
remove.className = 'icon-button';
remove.textContent = '×';
remove.setAttribute('aria-label', t('remove', { name: file.name }));
remove.addEventListener('click', () => {
state.files.splice(index, 1);
state.formError = null;
render();
});
item.append(fileNameElement(file.name), size, remove);
return item;
}),
);
el.selectionTotal.textContent = `${t('files', state.files.length)} · ${formatBytes(totalBytes(state.files))}`;
const problem = selectionProblem() ?? state.formError;
el.formError.hidden = !problem;
el.formError.textContent = problem ? t(problem.key, problem.params) : '';
const enabled = Boolean(cfg?.uploadsEnabled);
el.start.disabled = !enabled || state.files.length === 0 || selectionProblem() !== null;
}
function uploadedBytes(job) {
return job.offsets.reduce((sum, offset) => sum + offset, 0) + job.chunkLoaded;
}
function renderProgress() {
const job = state.job;
if (!job) return;
const done = Math.min(uploadedBytes(job), job.totalBytes);
const share = job.totalBytes > 0 ? done / job.totalBytes : 1;
el.progressBar.value = Math.round(share * 1000);
el.progressPercent.textContent = `${Math.floor(share * 100)}\u00a0%`;
let detail = t('progressDetail', { done: formatBytes(done), total: formatBytes(job.totalBytes) });
if (state.phase === 'finishing') {
detail = t('finishing');
} else if (!job.retrying && job.speed > 0 && Date.now() - job.startedAt > 4000 && done < job.totalBytes) {
detail += ` · ${t('eta', { time: formatDuration((job.totalBytes - done) / job.speed) })}`;
}
el.progressDetail.textContent = detail;
const file = job.files[job.current];
el.progressFile.textContent =
job.files.length > 1 && file
? t('currentFile', { index: job.current + 1, count: job.files.length, name: file.name })
: (file?.name ?? '');
el.progressRetry.hidden = !job.retrying;
}
let progressQueued = false;
function queueProgress() {
if (progressQueued) return;
progressQueued = true;
requestAnimationFrame(() => {
progressQueued = false;
if (state.phase === 'uploading' || state.phase === 'finishing') renderProgress();
});
}
function shareUrl(id) {
return `${location.origin}/d/${id}`;
}
function renderDone() {
const result = state.result;
if (!result) return;
el.shareLink.value = shareUrl(result.id);
el.openLink.href = `/d/${result.id}`;
el.copyLink.textContent = Date.now() < state.copiedUntil ? t('copied') : t('copy');
el.doneInfo.textContent = t('doneInfo', {
files: t('files', result.count),
size: formatBytes(result.bytes),
date: formatDate(result.expiresAt),
});
}
/** Übersetzt einen Fehler in eine Meldung: { key, params }. */
function describeError(err, { duringUpload = false } = {}) {
if (err?.unreadable) return { key: 'unreadable', params: { name: err.unreadable } };
if (!(err instanceof ApiError)) return { key: 'generic', params: { code: '?' } };
if (err.status === 0) return { key: 'network' };
switch (err.code) {
case 'code_required':
return { key: 'codeMissing' };
case 'code_invalid':
return { key: 'codeInvalid' };
case 'rate_limited':
return { key: 'rateLimited', params: { time: formatDuration(Number(err.body.retryAfter) || 60) } };
case 'storage_full':
return { key: 'storageFull' };
case 'uploads_disabled':
return { key: 'uploadsDisabled' };
case 'too_large':
return {
key: 'tooLarge',
params: { size: formatBytes(totalBytes(state.files)), max: formatBytes(Number(err.body.maxBytes) || 0) },
};
case 'too_many_files':
return { key: 'tooMany', params: { count: state.files.length, max: Number(err.body.maxFiles) || 0 } };
default:
if (duringUpload && (err.status === 404 || err.status === 403)) return { key: 'gone' };
return { key: 'generic', params: { code: err.code ?? err.status } };
}
}
function renderError() {
const job = state.job;
if (!job?.error) return;
const message = describeError(job.error, { duringUpload: true });
el.uploadError.textContent = t(message.key, message.params);
// Fortsetzen ergibt nur Sinn, wenn der Transfer auf dem Server noch existiert.
el.resume.hidden = message.key === 'gone' || message.key === 'unreadable';
el.errorProgress.textContent = t('uploadedSoFar', {
done: formatBytes(Math.min(uploadedBytes(job), job.totalBytes)),
total: formatBytes(job.totalBytes),
});
}
function renderRecent() {
const list = loadRecent();
el.recent.hidden = list.length === 0;
el.recentError.hidden = !state.recentError;
el.recentError.textContent = state.recentError ? t(state.recentError.key) : '';
el.recentList.replaceChildren(
...list.map((entry) => {
const item = document.createElement('li');
const main = document.createElement('div');
main.className = 'recent-main';
const link = document.createElement('a');
link.className = 'recent-link';
link.href = `/d/${entry.id}`;
link.append(fileNameElement(entry.name));
if (entry.count > 1) {
const more = document.createElement('span');
more.className = 'recent-more';
more.textContent = t('more', entry.count - 1);
link.append(more);
}
const meta = document.createElement('div');
meta.className = 'recent-meta';
meta.textContent = t('recentMeta', { size: formatBytes(entry.bytes), date: formatDate(entry.expiresAt) });
main.append(link, meta);
const actions = document.createElement('div');
actions.className = 'recent-actions';
const copy = document.createElement('button');
copy.type = 'button';
copy.className = 'button button-secondary button-small';
copy.textContent = t('copyLink');
copy.addEventListener('click', async () => {
if (await copyText(shareUrl(entry.id))) {
copy.textContent = t('copied');
setTimeout(() => {
copy.textContent = t('copyLink');
}, 1800);
}
});
// Löschen braucht zwei Klicks: Der erste fragt nach, der zweite löscht.
const armed = state.deleteArmed === entry.id;
const remove = document.createElement('button');
remove.type = 'button';
remove.className = `button button-small ${armed ? 'button-danger' : 'button-secondary'}`;
remove.textContent = armed ? t('confirmDelete') : t('delete');
remove.dataset.deleteId = entry.id;
remove.addEventListener('click', () => (armed ? deleteRecent(entry, remove) : armDelete(entry)));
actions.append(copy, remove);
item.append(main, actions);
return item;
}),
);
}
function render() {
if (state.phase === 'select') {
show('select');
renderSelect();
} else if (state.phase === 'uploading' || state.phase === 'finishing') {
show('progress');
renderProgress();
} else if (state.phase === 'done') {
show('done');
renderDone();
} else {
show('error');
renderError();
}
renderRecent();
}
// -------------------------------------------------------------- Upload
function isRetryable(err) {
if (!(err instanceof ApiError)) return false;
if (err.status === 0 || err.status === 408 || err.status === 429) return true;
if (err.status === 409 && err.code === 'busy') return true;
return err.status >= 500 && err.status !== 507;
}
function retryDelay(err, attempt) {
if (err instanceof ApiError && err.status === 429) {
return Math.min((Number(err.body.retryAfter) || 30) * 1000, 120_000);
}
return Math.min(1000 * 2 ** attempt, 30_000);
}
function checkCancelled(job) {
if (job.cancelled) throw CANCELLED;
}
/** Wartet; ein Abbruch des Uploads beendet das Warten sofort. */
function sleep(job, ms) {
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
job.wake = null;
resolve();
}, ms);
job.wake = () => {
clearTimeout(timer);
job.wake = null;
reject(CANCELLED);
};
});
}
function setRetrying(job, retrying) {
if (job.retrying === retrying) return;
job.retrying = retrying;
queueProgress();
}
function noteSpeed(job) {
const now = Date.now();
const elapsed = now - job.sampleAt;
if (elapsed < 1000) return;
const bytes = uploadedBytes(job);
const current = ((bytes - job.sampleBytes) * 1000) / elapsed;
if (current >= 0) job.speed = job.speed > 0 ? job.speed * 0.7 + current * 0.3 : current;
job.sampleAt = now;
job.sampleBytes = bytes;
}
/** Schickt ein Stück einer Datei. Liefert den neuen Stand vom Server. */
function sendChunk(job, index, offset, blob) {
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
let stalled = false;
let watchdog = null;
const arm = () => {
clearTimeout(watchdog);
watchdog = setTimeout(() => {
stalled = true;
xhr.abort();
}, STALL_MS);
};
const settle = () => {
clearTimeout(watchdog);
if (job.xhr === xhr) job.xhr = null;
};
xhr.open('PUT', `/api/transfers/${job.id}/files/${index}?offset=${offset}`);
xhr.setRequestHeader('Authorization', `Bearer ${job.uploadToken}`);
xhr.setRequestHeader('Content-Type', 'application/octet-stream');
xhr.responseType = 'json';
xhr.upload.onprogress = (event) => {
arm();
job.chunkLoaded = event.loaded;
noteSpeed(job);
queueProgress();
};
xhr.onload = () => {
settle();
const body = xhr.response;
if (xhr.status >= 200 && xhr.status < 300 && Number.isSafeInteger(body?.received)) resolve(body.received);
else reject(new ApiError(xhr.status, body));
};
xhr.onerror = () => {
settle();
reject(new ApiError(0, { error: 'network' }));
};
xhr.onabort = () => {
settle();
reject(job.cancelled && !stalled ? CANCELLED : new ApiError(0, { error: 'network' }));
};
job.xhr = xhr;
arm();
xhr.send(blob);
});
}
function checkedOffset(received, size) {
if (!Number.isSafeInteger(received) || received < 0 || received > size) {
throw new ApiError(500, { error: 'bad_offset' });
}
return received;
}
/** Fragt den Server, wie viel von jeder Datei schon angekommen ist. */
async function syncOffsets(job) {
const status = await api('GET', `/api/transfers/${job.id}/upload`, { token: job.uploadToken });
if (!Array.isArray(status?.files) || status.files.length !== job.files.length) {
throw new ApiError(500, { error: 'bad_status' });
}
job.offsets = status.files.map((file, i) => checkedOffset(file.received, job.files[i].size));
job.chunkLoaded = 0;
}
/** Schickt ein Stück und wiederholt es bei Verbindungsproblemen. */
async function sendChunkReliably(job, index, offset, blob) {
const size = job.files[index].size;
for (let attempt = 0; ; attempt += 1) {
checkCancelled(job);
try {
const received = await sendChunk(job, index, offset, blob);
setRetrying(job, false);
return checkedOffset(received, size);
} catch (err) {
job.chunkLoaded = 0;
if (err === CANCELLED) throw err;
// Der Server ist an einer anderen Stelle: dort weitermachen.
if (err instanceof ApiError && err.status === 409 && Number.isSafeInteger(err.body.received)) {
return checkedOffset(err.body.received, size);
}
if (!isRetryable(err) || attempt >= MAX_ATTEMPTS - 1) throw err;
// Liegt es an der Datei selbst (verschoben, geändert)? Dann hilft Warten nicht.
try {
await blob.slice(0, 1).arrayBuffer();
} catch {
throw Object.assign(new Error('unreadable'), { unreadable: job.files[index].name });
}
setRetrying(job, true);
await sleep(job, retryDelay(err, attempt));
try {
await syncOffsets(job);
if (job.offsets[index] !== offset) return job.offsets[index];
} catch (syncErr) {
if (!isRetryable(syncErr)) throw syncErr;
}
}
}
}
/** Wiederholt einen kurzen Aufruf bei Verbindungsproblemen. */
async function withRetries(job, call) {
for (let attempt = 0; ; attempt += 1) {
checkCancelled(job);
try {
const result = await call();
setRetrying(job, false);
return result;
} catch (err) {
if (!isRetryable(err) || attempt >= MAX_ATTEMPTS - 1) throw err;
setRetrying(job, true);
await sleep(job, retryDelay(err, attempt));
}
}
}
async function runUpload(job) {
state.phase = 'uploading';
job.error = null;
job.retrying = false;
job.sampleAt = Date.now();
job.sampleBytes = uploadedBytes(job);
render();
try {
if (job.needsSync) {
await withRetries(job, () => syncOffsets(job));
job.needsSync = false;
job.sampleBytes = uploadedBytes(job);
}
for (let index = 0; index < job.files.length; index += 1) {
const file = job.files[index];
job.current = index;
while (job.offsets[index] < file.size) {
checkCancelled(job);
const offset = job.offsets[index];
const blob = file.slice(offset, Math.min(offset + job.chunkBytes, file.size));
job.offsets[index] = await sendChunkReliably(job, index, offset, blob);
job.chunkLoaded = 0;
queueProgress();
}
}
state.phase = 'finishing';
renderProgress();
const done = await withRetries(job, () =>
api('POST', `/api/transfers/${job.id}/finish`, { token: job.uploadToken }),
);
checkCancelled(job);
state.result = {
id: job.id,
deleteToken: job.deleteToken,
expiresAt: done.expiresAt,
count: job.files.length,
bytes: job.totalBytes,
name: job.files[0].name,
};
saveRecent([state.result, ...loadRecent().filter((entry) => entry.id !== job.id)]);
state.job = null;
state.files = [];
state.phase = 'done';
render();
el.doneTitle.focus();
} catch (err) {
if (err === CANCELLED || job.cancelled) return;
job.error = err;
job.needsSync = true;
state.phase = 'error';
render();
el.errorTitle.focus();
}
}
async function startUpload() {
const cfg = state.config;
if (!cfg?.uploadsEnabled || state.files.length === 0 || selectionProblem()) return;
const code = el.code.value.trim();
if (cfg.codeRequired && code === '') {
state.formError = { key: 'codeMissing' };
render();
el.code.setAttribute('aria-invalid', 'true');
el.code.focus();
return;
}
const files = [...state.files];
const job = {
files,
totalBytes: totalBytes(files),
offsets: files.map(() => 0),
chunkLoaded: 0,
current: 0,
id: null,
uploadToken: null,
deleteToken: null,
chunkBytes: 0,
xhr: null,
wake: null,
cancelled: false,
retrying: false,
needsSync: false,
error: null,
speed: 0,
sampleAt: Date.now(),
sampleBytes: 0,
startedAt: Date.now(),
};
state.job = job;
state.formError = null;
state.phase = 'uploading';
render();
el.progressTitle.focus();
try {
const created = await api('POST', '/api/transfers', {
json: {
code: cfg.codeRequired ? code : undefined,
expiryDays: Number(el.expiry.value) || cfg.defaultExpiryDays,
files: files.map((file) => ({ name: file.name, size: file.size })),
},
});
if (cfg.codeRequired) rememberCode(code);
job.id = created.id;
job.uploadToken = created.uploadToken;
job.deleteToken = created.deleteToken;
job.chunkBytes = created.chunkBytes;
} catch (err) {
// Noch ist nichts hochgeladen: zurück zum Formular mit einer Meldung.
if (state.job !== job) return;
state.job = null;
state.phase = 'select';
state.formError = describeError(err);
render();
if (err instanceof ApiError && (err.code === 'code_invalid' || err.code === 'code_required')) {
if (err.code === 'code_invalid') forgetCode();
el.code.setAttribute('aria-invalid', 'true');
el.code.focus();
el.code.select();
}
return;
}
if (job.cancelled) {
discardOnServer(job);
return;
}
await runUpload(job);
}
function discardOnServer(job) {
if (!job.id) return;
api('DELETE', `/api/transfers/${job.id}`, { token: job.deleteToken }).catch(() => {
// Nicht schlimm: Angefangene Uploads räumt der Server später selbst weg.
});
}
/** Bricht den laufenden oder unterbrochenen Upload ab und verwirft ihn. */
function cancelUpload() {
const job = state.job;
if (!job) return;
job.cancelled = true;
job.xhr?.abort();
job.wake?.();
discardOnServer(job);
state.job = null;
state.phase = 'select';
render();
el.start.focus();
}
let disarmTimer = null;
/** Erster Klick auf „Löschen“: Der Knopf fragt für ein paar Sekunden nach. */
function armDelete(entry) {
clearTimeout(disarmTimer);
state.deleteArmed = entry.id;
state.recentError = null;
renderRecent();
el.recentList.querySelector(`[data-delete-id="${entry.id}"]`)?.focus();
disarmTimer = setTimeout(() => {
state.deleteArmed = null;
renderRecent();
}, 5000);
}
async function deleteRecent(entry, button) {
clearTimeout(disarmTimer);
button.disabled = true;
state.deleteArmed = null;
try {
await api('DELETE', `/api/transfers/${entry.id}`, { token: entry.deleteToken });
} catch (err) {
// 404/403: Der Transfer ist schon weg – dann nur aus der Liste nehmen.
if (!(err instanceof ApiError) || (err.status !== 404 && err.status !== 403)) {
state.recentError = { key: 'deleteFailed' };
renderRecent();
return;
}
}
saveRecent(loadRecent().filter((item) => item.id !== entry.id));
if (state.phase === 'done' && state.result?.id === entry.id) {
state.result = null;
state.phase = 'select';
}
render();
}
// ----------------------------------------------------------- Ereignisse
el.fileInput.addEventListener('change', () => {
addFiles(el.fileInput.files);
el.fileInput.value = '';
});
el.clearFiles.addEventListener('click', () => {
state.files = [];
state.formError = null;
render();
});
// Die ganze Seite nimmt Dateien an, damit ein danebengezogenes Bild nicht
// versehentlich im Browser geöffnet wird.
let dragDepth = 0;
const hasFiles = (event) => [...(event.dataTransfer?.types ?? [])].includes('Files');
window.addEventListener('dragenter', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
dragDepth += 1;
if (state.phase === 'select') el.dropzone.classList.add('is-dragover');
});
window.addEventListener('dragover', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
event.dataTransfer.dropEffect = state.phase === 'select' ? 'copy' : 'none';
});
window.addEventListener('dragleave', (event) => {
if (!hasFiles(event)) return;
dragDepth = Math.max(0, dragDepth - 1);
if (dragDepth === 0) el.dropzone.classList.remove('is-dragover');
});
window.addEventListener('drop', (event) => {
if (!hasFiles(event)) return;
event.preventDefault();
dragDepth = 0;
el.dropzone.classList.remove('is-dragover');
if (state.phase !== 'select') return;
const { files, skippedFolder } = filesFromDrop(event.dataTransfer);
addFiles(files, { skippedFolder });
});
// Dateien aus der Zwischenablage (z. B. ein kopiertes Bildschirmfoto)
document.addEventListener('paste', (event) => {
const files = event.clipboardData?.files;
if (state.phase !== 'select' || !files || files.length === 0) return;
event.preventDefault();
addFiles(files);
});
el.code.addEventListener('input', () => {
el.code.removeAttribute('aria-invalid');
if (state.formError && ['codeMissing', 'codeInvalid'].includes(state.formError.key)) {
state.formError = null;
renderSelect();
}
});
el.stepSelect.addEventListener('submit', (event) => {
event.preventDefault();
startUpload();
});
el.cancel.addEventListener('click', cancelUpload);
el.discard.addEventListener('click', cancelUpload);
el.resume.addEventListener('click', () => {
if (state.job && state.phase === 'error') {
runUpload(state.job);
el.progressTitle.focus();
}
});
el.copyLink.addEventListener('click', async () => {
if (await copyText(el.shareLink.value)) {
state.copiedUntil = Date.now() + 2000;
renderDone();
setTimeout(() => {
if (state.phase === 'done') renderDone();
}, 2100);
} else {
el.shareLink.focus();
el.shareLink.select();
}
});
el.shareLink.addEventListener('focus', () => el.shareLink.select());
el.newUpload.addEventListener('click', () => {
state.result = null;
state.phase = 'select';
render();
el.dropzone.scrollIntoView({ block: 'nearest' });
});
window.addEventListener('beforeunload', (event) => {
if (state.phase === 'uploading' || state.phase === 'finishing') {
event.preventDefault();
event.returnValue = '';
}
});
onLangChange(render);
// ---------------------------------------------------------------- Start
const savedCode = storageGet(localStorage, 'uploadCode');
if (savedCode) {
el.code.value = savedCode;
el.rememberCode.checked = true;
} else {
el.code.value = storageGet(sessionStorage, 'uploadCode') ?? '';
}
render();
try {
state.config = await api('GET', '/api/config');
if (!state.config.uploadsEnabled) state.formError = { key: 'uploadsDisabled' };
} catch (err) {
state.formError = describeError(err);
}
render();
+3
View File
@@ -0,0 +1,3 @@
# Private Seite: Suchmaschinen sollen hier nichts erfassen.
User-agent: *
Disallow: /
+49
View File
@@ -0,0 +1,49 @@
#!/usr/bin/env node
// Startet den Dateitransfer. Einstellungen kommen aus Umgebungsvariablen;
// liegt neben dieser Datei eine .env, wird sie zusätzlich gelesen.
import path from 'node:path';
import { createApp, defaultLog as log } from './src/app.js';
import { loadConfig } from './src/config.js';
const rootDir = import.meta.dirname;
try {
process.loadEnvFile(path.join(rootDir, '.env'));
} catch (err) {
if (err.code !== 'ENOENT') {
console.error(`.env konnte nicht gelesen werden: ${err.message}`);
process.exit(1);
}
}
let config;
try {
config = loadConfig(process.env, { rootDir });
} catch (err) {
console.error(`Einstellungen fehlerhaft – ${err.message}`);
process.exit(1);
}
const app = await createApp(config);
const address = await app.listen();
log(`FileTransfer läuft auf http://${address.address}:${address.port} – ${app.store.size} Transfer(s) vorhanden`);
if (config.openUploads) {
log('Achtung: OPEN_UPLOADS ist gesetzt – jeder darf ohne Code hochladen.');
} else if (config.codes.length === 0) {
log('Achtung: Kein Upload-Code gesetzt (UPLOAD_CODES) – Hochladen ist gesperrt.');
}
for (const code of config.codes) {
if (code.short) log(`Achtung: Der Upload-Code "${code.label}" ist kürzer als 8 Zeichen.`);
}
let stopping = false;
for (const signal of ['SIGINT', 'SIGTERM']) {
process.on(signal, async () => {
if (stopping) return;
stopping = true;
log(`${signal} empfangen, beende …`);
await app.close();
process.exit(0);
});
}
+563
View File
@@ -0,0 +1,563 @@
// HTTP-Server: Seiten, Schnittstelle für den Upload und die Downloads.
//
// GET / Upload-Seite
// GET /d/<kennung> Download-Seite
// GET /d/<kennung>/<nr> Datei herunterladen
// GET /api/config Grenzen und Fristen für die Oberfläche
// POST /api/transfers Transfer anlegen (Upload-Code nötig)
// GET /api/transfers/<kennung> Dateiliste eines fertigen Transfers
// DELETE /api/transfers/<kennung> Transfer löschen (Lösch-Token)
// GET /api/transfers/<kennung>/upload Stand des Uploads (Upload-Token)
// PUT /api/transfers/<kennung>/files/<nr>?offset=<n> ein Stück hochladen
// POST /api/transfers/<kennung>/finish Upload abschließen
import fsp from 'node:fs/promises';
import http from 'node:http';
import { pipeline } from 'node:stream/promises';
import { RateLimiter } from './limiter.js';
import { Pages } from './pages.js';
import { Store } from './store.js';
import {
HttpError,
ID_PATTERN,
contentDisposition,
hashEquals,
ipKey,
isPlainObject,
sanitizeName,
sha256,
} from './util.js';
const JSON_LIMIT = 256 * 1024;
const JSON_TIMEOUT_MS = 20_000;
const MAX_NAME_CHARS = 1024;
const BASE_HEADERS = {
'Content-Security-Policy':
"default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; " +
"connect-src 'self'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
'X-Content-Type-Options': 'nosniff',
'X-Frame-Options': 'DENY',
'Referrer-Policy': 'no-referrer',
'Cross-Origin-Opener-Policy': 'same-origin',
'Cross-Origin-Resource-Policy': 'same-origin',
};
// Hochgeladene Dateien werden nie als Seite ausgeführt, nur gespeichert.
const FILE_CSP = "default-src 'none'; sandbox; frame-ancestors 'none'";
const RE_API_TRANSFER = /^\/api\/transfers\/([^/]+)$/;
const RE_API_UPLOAD = /^\/api\/transfers\/([^/]+)\/upload$/;
const RE_API_FILE = /^\/api\/transfers\/([^/]+)\/files\/(\d{1,5})$/;
const RE_API_FINISH = /^\/api\/transfers\/([^/]+)\/finish$/;
const RE_PAGE = /^\/d\/([^/]+)$/;
const RE_FILE = /^\/d\/([^/]+)\/(\d{1,5})$/;
/** Protokollzeile mit Ortszeit (Zeitzone über die Umgebungsvariable TZ). */
export function defaultLog(message) {
console.log(`${new Date().toLocaleString('sv-SE')} ${message}`);
}
export async function createApp(config, { log = defaultLog } = {}) {
const store = new Store(config, log);
await store.init();
const pages = new Pages(config);
const limits = {
// falsche Upload-Codes je Adresse
codeFailures: new RateLimiter({ limit: 10, windowMs: 10 * 60_000 }),
// neu angelegte Transfers je Adresse
creations: new RateLimiter({ limit: 60, windowMs: 60 * 60_000 }),
// Abrufe nicht vorhandener Kennungen je Adresse (gegen Durchprobieren)
misses: new RateLimiter({ limit: 60, windowMs: 10 * 60_000 }),
};
// ---------------------------------------------------------------- Helfer
function clientKey(req) {
let address = req.socket.remoteAddress;
if (config.trustProxy > 0) {
const forwarded = String(req.headers['x-forwarded-for'] ?? '')
.split(',')
.map((part) => part.trim())
.filter(Boolean);
if (forwarded.length > 0) address = forwarded[Math.max(0, forwarded.length - config.trustProxy)];
}
return ipKey(address);
}
function only(req, ...methods) {
if (!methods.includes(req.method)) throw new HttpError(405, 'method_not_allowed', { allow: methods });
}
function tooMany(limiter, key) {
return new HttpError(429, 'rate_limited', { retryAfter: limiter.retryAfter(key) });
}
function sendJson(res, status, body) {
const data = Buffer.from(JSON.stringify(body), 'utf8');
res.writeHead(status, {
'Content-Type': 'application/json; charset=utf-8',
'Content-Length': data.length,
'Cache-Control': 'no-store',
});
res.end(data);
}
function sendText(req, res, status, text) {
const data = Buffer.from(`${text}\n`, 'utf8');
res.writeHead(status, {
'Content-Type': 'text/plain; charset=utf-8',
'Content-Length': data.length,
'Cache-Control': 'no-store',
});
res.end(req.method === 'HEAD' ? undefined : data);
}
/** Sendet eine Seite oder statische Datei aus dem Arbeitsspeicher. */
function sendEntry(req, res, item, status = 200) {
res.setHeader('Content-Type', item.type);
res.setHeader('Cache-Control', 'no-cache');
if (status === 200) {
res.setHeader('ETag', item.etag);
if (req.headers['if-none-match'] === item.etag) {
res.writeHead(304);
res.end();
return;
}
}
res.setHeader('Content-Length', item.body.length);
res.writeHead(status);
res.end(req.method === 'HEAD' ? undefined : item.body);
}
function readJson(req) {
return new Promise((resolve, reject) => {
const type = String(req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase();
if (type !== 'application/json') return reject(new HttpError(415, 'unsupported_media_type'));
if (Number(req.headers['content-length']) > JSON_LIMIT) return reject(new HttpError(413, 'body_too_large'));
const chunks = [];
let size = 0;
const done = (err, value) => {
clearTimeout(timer);
req.off('data', onData).off('end', onEnd).off('close', onClose);
if (err) {
req.pause();
reject(err);
} else {
resolve(value);
}
};
const onData = (chunk) => {
size += chunk.length;
if (size > JSON_LIMIT) done(new HttpError(413, 'body_too_large'));
else chunks.push(chunk);
};
const onEnd = () => {
try {
done(null, JSON.parse(Buffer.concat(chunks).toString('utf8')));
} catch {
done(new HttpError(400, 'invalid_json'));
}
};
const onClose = () => done(new HttpError(400, 'aborted'));
const timer = setTimeout(() => done(new HttpError(408, 'request_timeout')), JSON_TIMEOUT_MS);
req.on('data', onData).on('end', onEnd).on('close', onClose);
});
}
/** Liest den Rest eines Anfragekörpers und verwirft ihn. */
function drain(req) {
return new Promise((resolve) => {
if (req.complete || req.destroyed) return resolve();
req.once('end', resolve).once('close', resolve);
req.resume();
});
}
function requireToken(req, expectedHash) {
const match = /^Bearer\s+([\w-]{20,200})$/i.exec(String(req.headers.authorization ?? ''));
if (!match || !hashEquals(sha256(match[1]), expectedHash)) throw new HttpError(403, 'forbidden');
}
/** Sucht einen Transfer; Fehlversuche werden gezählt. */
function lookup(rawId, ip, { readyOnly }) {
if (limits.misses.blocked(ip)) throw tooMany(limits.misses, ip);
const id = rawId.toLowerCase();
const transfer = ID_PATTERN.test(id) ? (readyOnly ? store.getReady(id) : store.get(id)) : undefined;
if (!transfer) limits.misses.hit(ip);
return transfer;
}
function mustFind(rawId, ip, options) {
const transfer = lookup(rawId, ip, options);
if (!transfer) throw new HttpError(404, 'not_found');
return transfer;
}
function matchCode(code) {
const hash = sha256(code);
let found = null;
for (const entry of config.codes) {
if (hashEquals(hash, entry.hash)) found ??= entry;
}
return found;
}
// ------------------------------------------------------------ Upload-API
function publicConfig() {
return {
uploadsEnabled: config.openUploads || config.codes.length > 0,
codeRequired: !config.openUploads,
maxTransferBytes: config.maxTransferBytes,
maxFiles: config.maxFiles,
expiryDays: config.expiryDays,
defaultExpiryDays: config.defaultExpiryDays,
};
}
function validateFiles(list) {
if (!Array.isArray(list) || list.length === 0) throw new HttpError(400, 'invalid_request');
if (list.length > config.maxFiles) throw new HttpError(413, 'too_many_files', { maxFiles: config.maxFiles });
let total = 0;
const files = list.map((item) => {
const ok =
isPlainObject(item) &&
typeof item.name === 'string' &&
item.name.length <= MAX_NAME_CHARS &&
Number.isSafeInteger(item.size) &&
item.size >= 0;
if (!ok) throw new HttpError(400, 'invalid_request');
total += item.size;
return { name: sanitizeName(item.name), size: item.size };
});
if (total > config.maxTransferBytes) {
throw new HttpError(413, 'too_large', { maxBytes: config.maxTransferBytes });
}
return files;
}
async function createTransfer(req, res, ip) {
if (!config.openUploads && config.codes.length === 0) throw new HttpError(503, 'uploads_disabled');
if (limits.codeFailures.blocked(ip)) throw tooMany(limits.codeFailures, ip);
const body = await readJson(req);
if (!isPlainObject(body)) throw new HttpError(400, 'invalid_request');
let codeLabel = null;
if (!config.openUploads) {
const code = typeof body.code === 'string' ? body.code.trim() : '';
if (code === '') throw new HttpError(401, 'code_required');
const match = matchCode(code);
if (!match) {
limits.codeFailures.hit(ip);
throw new HttpError(401, 'code_invalid');
}
codeLabel = match.label;
}
const files = validateFiles(body.files);
const expiryDays = body.expiryDays ?? config.defaultExpiryDays;
if (!config.expiryDays.includes(expiryDays)) throw new HttpError(400, 'invalid_request');
if (!limits.creations.take(ip)) throw tooMany(limits.creations, ip);
const { transfer, uploadToken, deleteToken } = await store.create({ files, expiryDays, codeLabel });
log(
`Transfer ${transfer.id} angelegt: ${files.length} Datei(en), ${transfer.totalBytes} Bytes` +
(codeLabel ? `, Code "${codeLabel}"` : ''),
);
sendJson(res, 201, {
id: transfer.id,
uploadToken,
deleteToken,
chunkBytes: config.chunkBytes,
files: transfer.files.map(({ name, size }) => ({ name, size })),
});
}
async function putChunk(req, res, ip, rawId, index, query) {
const header = req.headers['content-length'];
const declared = header === undefined ? null : Number(header);
try {
const transfer = mustFind(rawId, ip, { readyOnly: false });
requireToken(req, transfer.uploadTokenHash);
const file = transfer.files[index];
if (!file) throw new HttpError(404, 'not_found');
const offsetText = query.get('offset') ?? '';
if (!/^\d{1,16}$/.test(offsetText)) throw new HttpError(400, 'invalid_request');
const offset = Number(offsetText);
if (declared !== null && declared > Math.min(config.chunkBytes, Math.max(0, file.size - offset))) {
throw new HttpError(413, 'chunk_too_large');
}
const received = await store.writeChunk(transfer, index, offset, req, config.chunkBytes);
sendJson(res, 200, { received });
} catch (err) {
// Erst antworten, wenn der Browser sein Stück losgeworden ist; sonst
// sieht er statt der Fehlermeldung nur einen Verbindungsabbruch.
if (err instanceof HttpError && declared !== null && declared <= config.chunkBytes) await drain(req);
throw err;
}
}
function uploadStatus(req, res, ip, rawId) {
const transfer = mustFind(rawId, ip, { readyOnly: false });
requireToken(req, transfer.uploadTokenHash);
sendJson(res, 200, {
state: transfer.state,
expiresAt: transfer.expiresAt,
files: transfer.files.map(({ size, received }) => ({ size, received })),
});
}
async function finishTransfer(req, res, ip, rawId) {
const transfer = mustFind(rawId, ip, { readyOnly: false });
requireToken(req, transfer.uploadTokenHash);
const wasReady = transfer.state === 'ready';
await store.finish(transfer);
if (!wasReady) log(`Transfer ${transfer.id} fertig, gültig bis ${new Date(transfer.expiresAt).toLocaleString('sv-SE')}`);
sendJson(res, 200, { id: transfer.id, expiresAt: transfer.expiresAt });
}
async function deleteTransfer(req, res, ip, rawId) {
const transfer = mustFind(rawId, ip, { readyOnly: false });
requireToken(req, transfer.deleteTokenHash);
await store.remove(transfer.id);
log(`Transfer ${transfer.id} gelöscht (vom Absender)`);
res.writeHead(204, { 'Cache-Control': 'no-store' });
res.end();
}
function transferInfo(req, res, ip, rawId) {
const transfer = mustFind(rawId, ip, { readyOnly: true });
sendJson(res, 200, {
id: transfer.id,
createdAt: transfer.finishedAt,
expiresAt: transfer.expiresAt,
totalBytes: transfer.totalBytes,
files: transfer.files.map(({ name, size }) => ({ name, size })),
});
}
// -------------------------------------------------------------- Download
/** Wertet einen Range-Header aus: Bereich, null (ganze Datei) oder 'invalid'. */
function parseRange(header, size) {
const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
if (!match || (match[1] === '' && match[2] === '')) return null;
if (match[1] === '') {
const suffix = Number(match[2]);
if (suffix === 0 || size === 0) return 'invalid';
return { start: Math.max(0, size - suffix), end: size - 1 };
}
const start = Number(match[1]);
const end = match[2] === '' ? size - 1 : Math.min(Number(match[2]), size - 1);
if (start >= size) return 'invalid';
if (end < start) return null;
return { start, end };
}
async function sendFile(req, res, ip, rawId, index) {
const transfer = mustFind(rawId, ip, { readyOnly: true });
const file = transfer.files[index];
if (!file) throw new HttpError(404, 'not_found');
let handle;
try {
handle = await fsp.open(store.filePath(transfer, index), 'r');
const stat = await handle.stat();
if (stat.size !== file.size) throw new HttpError(404, 'not_found');
} catch (err) {
await handle?.close();
if (err.code === 'ENOENT') throw new HttpError(404, 'not_found');
throw err;
}
const etag = `"${transfer.id}-${index}-${file.size}"`;
res.setHeader('Content-Type', 'application/octet-stream');
res.setHeader('Content-Disposition', contentDisposition(file.name));
res.setHeader('Content-Security-Policy', FILE_CSP);
res.setHeader('Accept-Ranges', 'bytes');
res.setHeader('ETag', etag);
res.setHeader('Cache-Control', 'private, no-cache');
res.setHeader('X-Robots-Tag', 'noindex, nofollow');
let range = null;
const rangeHeader = req.headers.range;
const ifRange = req.headers['if-range'];
if (rangeHeader && (!ifRange || ifRange === etag)) range = parseRange(rangeHeader, file.size);
if (range === 'invalid') {
await handle.close();
res.writeHead(416, { 'Content-Range': `bytes */${file.size}`, 'Content-Length': 0 });
res.end();
return;
}
const start = range ? range.start : 0;
const end = range ? range.end : file.size - 1;
res.setHeader('Content-Length', end - start + 1);
if (range) res.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`);
res.writeHead(range ? 206 : 200);
if (req.method === 'HEAD' || file.size === 0) {
await handle.close();
res.end();
return;
}
try {
await pipeline(handle.createReadStream({ start, end }), res);
} catch {
// Der Besucher hat den Download abgebrochen; nichts weiter zu tun.
res.destroy();
}
}
// --------------------------------------------------------------- Routing
async function handle(req, res) {
for (const [name, value] of Object.entries(BASE_HEADERS)) res.setHeader(name, value);
const raw = req.url ?? '';
if (!raw.startsWith('/')) throw new HttpError(400, 'invalid_request');
const mark = raw.indexOf('?');
let pathname = mark === -1 ? raw : raw.slice(0, mark);
const query = new URLSearchParams(mark === -1 ? '' : raw.slice(mark + 1));
if (pathname.length > 1 && pathname.endsWith('/')) pathname = pathname.slice(0, -1);
const ip = clientKey(req);
let m;
if (pathname === '/healthz') {
only(req, 'GET', 'HEAD');
return sendText(req, res, 200, 'ok');
}
if (pathname === '/api/config') {
only(req, 'GET');
return sendJson(res, 200, publicConfig());
}
if (pathname === '/api/transfers') {
only(req, 'POST');
return createTransfer(req, res, ip);
}
if ((m = RE_API_TRANSFER.exec(pathname))) {
only(req, 'GET', 'DELETE');
return req.method === 'GET' ? transferInfo(req, res, ip, m[1]) : deleteTransfer(req, res, ip, m[1]);
}
if ((m = RE_API_UPLOAD.exec(pathname))) {
only(req, 'GET');
return uploadStatus(req, res, ip, m[1]);
}
if ((m = RE_API_FILE.exec(pathname))) {
only(req, 'PUT');
return putChunk(req, res, ip, m[1], Number(m[2]), query);
}
if ((m = RE_API_FINISH.exec(pathname))) {
only(req, 'POST');
return finishTransfer(req, res, ip, m[1]);
}
if (pathname === '/api' || pathname.startsWith('/api/')) throw new HttpError(404, 'not_found');
if ((m = RE_FILE.exec(pathname))) {
only(req, 'GET', 'HEAD');
return sendFile(req, res, ip, m[1], Number(m[2]));
}
if ((m = RE_PAGE.exec(pathname))) {
only(req, 'GET', 'HEAD');
const transfer = lookup(m[1], ip, { readyOnly: true });
res.setHeader('X-Robots-Tag', 'noindex, nofollow');
return transfer
? sendEntry(req, res, pages.page('download'))
: sendEntry(req, res, pages.page('download-missing'), 404);
}
if (pathname === '/') {
only(req, 'GET', 'HEAD');
return sendEntry(req, res, pages.page('index'));
}
const asset = pages.asset(pathname);
if (asset) {
only(req, 'GET', 'HEAD');
return sendEntry(req, res, asset);
}
throw new HttpError(404, 'not_found');
}
function fail(req, res, err) {
if (res.destroyed || res.writableEnded) return;
if (res.headersSent) {
res.destroy();
return;
}
let status = 500;
let code = 'internal';
let extra = {};
if (err instanceof HttpError) {
({ status, code, extra } = err);
} else if (!req.complete && (req.destroyed || req.socket.destroyed)) {
return; // Verbindung ist schon weg
} else {
log(`Fehler bei ${req.method} ${String(req.url).split('?')[0]}: ${err?.stack ?? err}`);
}
// Ein nicht gelesener Anfragekörper wird nicht mehr abgewartet.
if (!req.complete) res.setHeader('Connection', 'close');
if (status === 405) res.setHeader('Allow', extra.allow.join(', '));
if (status === 429) res.setHeader('Retry-After', String(extra.retryAfter));
const isApi = String(req.url).startsWith('/api');
if (isApi) {
sendJson(res, status, { error: code, ...(status === 405 ? {} : extra) });
} else if (status === 404) {
sendEntry(req, res, pages.page('404'), 404);
} else {
sendText(req, res, status, status === 429 ? 'Zu viele Anfragen – too many requests.' : `Fehler ${status}`);
}
}
// ---------------------------------------------------------------- Server
const server = http.createServer(
{
// Länger als übliche Leerlaufzeiten eines vorgeschalteten Proxys.
keepAliveTimeout: 130_000,
headersTimeout: 30_000,
requestTimeout: 3_600_000,
},
(req, res) => {
req.on('error', () => {});
res.on('error', () => {});
handle(req, res).catch((err) => fail(req, res, err));
},
);
// Verbindungen, auf denen sich 150 Sekunden nichts bewegt, werden beendet.
server.setTimeout(150_000);
const sweepTimer = setInterval(() => {
store.sweep().catch((err) => log(`Fehler beim Aufräumen: ${err?.stack ?? err}`));
}, config.sweepIntervalMs);
sweepTimer.unref();
return {
config,
server,
store,
limits,
listen() {
return new Promise((resolve, reject) => {
server.once('error', reject);
server.listen(config.port, config.host, () => {
server.off('error', reject);
resolve(server.address());
});
});
},
close({ graceMs = 5000 } = {}) {
clearInterval(sweepTimer);
return new Promise((resolve) => {
const force = setTimeout(() => server.closeAllConnections(), graceMs);
server.close(() => {
clearTimeout(force);
resolve();
});
server.closeIdleConnections();
});
},
};
}
+125
View File
@@ -0,0 +1,125 @@
// Liest die Einstellungen aus Umgebungsvariablen (siehe .env.example).
import path from 'node:path';
import { sha256 } from './util.js';
const SIZE_UNITS = {
'': 1,
b: 1,
k: 1024,
kb: 1024,
m: 1024 ** 2,
mb: 1024 ** 2,
g: 1024 ** 3,
gb: 1024 ** 3,
t: 1024 ** 4,
tb: 1024 ** 4,
};
/** "5GB", "500 MB", "1048576" -> Bytes (1 GB = 1024 MB). */
export function parseSize(text) {
const match = /^\s*(\d+(?:[.,]\d+)?)\s*([a-z]*)\s*$/i.exec(String(text));
const unit = match ? match[2].toLowerCase().replace('i', '') : null;
if (!match || !(unit in SIZE_UNITS)) {
throw new Error(`"${text}" ist keine gültige Größenangabe (Beispiele: 500MB, 5GB).`);
}
return Math.round(Number(match[1].replace(',', '.')) * SIZE_UNITS[unit]);
}
/**
* "freunde:apfel-kuchen-73,anna:noch-ein-code" -> [{ label, hash, short }].
* Die Codes selbst bleiben nicht im Speicher, nur ihre Hashes.
*/
export function parseCodes(text) {
const codes = [];
for (const raw of String(text).split(/[,\n]/)) {
const entry = raw.trim();
if (!entry) continue;
const sep = entry.indexOf(':');
const label = sep > 0 ? entry.slice(0, sep).trim() : `code${codes.length + 1}`;
const code = sep > 0 ? entry.slice(sep + 1).trim() : entry;
if (!code) throw new Error(`UPLOAD_CODES: Für "${label}" fehlt der Code.`);
if (!/^[\w.-]{1,32}$/.test(label)) {
throw new Error(
`UPLOAD_CODES: Der Name "${label}" darf nur Buchstaben, Ziffern, Punkt, Binde- und Unterstrich enthalten.`,
);
}
if (codes.some((c) => c.label === label)) {
throw new Error(`UPLOAD_CODES: Der Name "${label}" kommt doppelt vor.`);
}
codes.push({ label, hash: sha256(code), short: code.length < 8 });
}
return codes;
}
export function loadConfig(env, { rootDir }) {
const str = (key, fallback = '') => {
const value = (env[key] ?? '').trim();
return value === '' ? fallback : value;
};
const int = (key, fallback, min, max) => {
const value = str(key, String(fallback));
if (!/^\d+$/.test(value) || Number(value) < min || Number(value) > max) {
throw new Error(`${key}: "${value}" muss eine ganze Zahl von ${min} bis ${max} sein.`);
}
return Number(value);
};
const bool = (key) => /^(1|true|yes|ja|on)$/i.test(str(key));
const size = (key, fallback) => {
try {
return parseSize(str(key, fallback));
} catch (err) {
throw new Error(`${key}: ${err.message}`);
}
};
const expiryDays = [
...new Set(
str('EXPIRY_DAYS', '1,7,30')
.split(',')
.map((part) => part.trim())
.filter(Boolean)
.map((part) => {
if (!/^\d+$/.test(part) || Number(part) < 1 || Number(part) > 365) {
throw new Error(`EXPIRY_DAYS: "${part}" muss eine Zahl von 1 bis 365 sein.`);
}
return Number(part);
}),
),
].sort((a, b) => a - b);
if (expiryDays.length === 0) throw new Error('EXPIRY_DAYS: Mindestens eine Frist angeben.');
const defaultExpiryDays = int('DEFAULT_EXPIRY_DAYS', expiryDays.includes(7) ? 7 : expiryDays[0], 1, 365);
if (!expiryDays.includes(defaultExpiryDays)) {
throw new Error(`DEFAULT_EXPIRY_DAYS: ${defaultExpiryDays} steht nicht in EXPIRY_DAYS (${expiryDays.join(', ')}).`);
}
const chunkBytes = size('CHUNK_SIZE', '8MB');
if (chunkBytes < 256 * 1024 || chunkBytes > 64 * 1024 ** 2) {
throw new Error('CHUNK_SIZE: Erlaubt sind 256KB bis 64MB.');
}
const siteName = str('SITE_NAME', 'shiuuji.de');
if (siteName.length > 60) throw new Error('SITE_NAME: Höchstens 60 Zeichen.');
return {
rootDir,
dataDir: path.resolve(rootDir, str('DATA_DIR', 'data')),
host: str('HOST', '127.0.0.1'),
port: int('PORT', 8083, 0, 65535),
siteName,
codes: parseCodes(str('UPLOAD_CODES')),
openUploads: bool('OPEN_UPLOADS'),
maxTransferBytes: size('MAX_TRANSFER_SIZE', '5GB'),
maxFiles: int('MAX_FILES', 200, 1, 5000),
maxTransfers: int('MAX_TRANSFERS', 5000, 1, 1_000_000),
storageQuotaBytes: size('STORAGE_QUOTA', '50GB'),
minFreeBytes: size('MIN_FREE_SPACE', '5GB'),
expiryDays,
defaultExpiryDays,
chunkBytes,
staleUploadMs: int('STALE_UPLOAD_HOURS', 24, 1, 720) * 3_600_000,
sweepIntervalMs: 60_000,
trustProxy: int('TRUST_PROXY', 0, 0, 5),
dev: bool('DEV'),
};
}
+63
View File
@@ -0,0 +1,63 @@
// Einfache Zugriffsbegrenzung im Arbeitsspeicher: höchstens `limit` Ereignisse
// je Schlüssel (zum Beispiel je IP-Adresse) innerhalb von `windowMs`.
export class RateLimiter {
#entries = new Map();
constructor({ limit, windowMs, maxKeys = 20_000 }) {
this.limit = limit;
this.windowMs = windowMs;
this.maxKeys = maxKeys;
}
#current(key, now) {
const entry = this.#entries.get(key);
if (!entry) return null;
if (entry.resetAt > now) return entry;
this.#entries.delete(key);
return null;
}
/** Ist das Limit für diesen Schlüssel gerade ausgeschöpft? */
blocked(key, now = Date.now()) {
const entry = this.#current(key, now);
return entry !== null && entry.count >= this.limit;
}
/** Zählt ein Ereignis. */
hit(key, now = Date.now()) {
let entry = this.#current(key, now);
if (!entry) {
this.#makeRoom(now);
entry = { count: 0, resetAt: now + this.windowMs };
this.#entries.set(key, entry);
}
entry.count += 1;
}
/** Zählt ein Ereignis, falls noch Platz ist. Gibt zurück, ob es erlaubt war. */
take(key, now = Date.now()) {
if (this.blocked(key, now)) return false;
this.hit(key, now);
return true;
}
/** Sekunden, bis der Schlüssel wieder frei ist (mindestens 1). */
retryAfter(key, now = Date.now()) {
const entry = this.#current(key, now);
return entry ? Math.max(1, Math.ceil((entry.resetAt - now) / 1000)) : 1;
}
// Hält die Tabelle klein, auch wenn sehr viele verschiedene Adressen anfragen.
#makeRoom(now) {
if (this.#entries.size < this.maxKeys) return;
for (const [key, entry] of this.#entries) {
if (entry.resetAt <= now) this.#entries.delete(key);
}
if (this.#entries.size < this.maxKeys) return;
let remove = Math.ceil(this.maxKeys / 10);
for (const key of this.#entries.keys()) {
this.#entries.delete(key);
if (--remove <= 0) break;
}
}
}
+85
View File
@@ -0,0 +1,85 @@
// Lädt die HTML-Seiten (pages/) und die statischen Dateien (public/) einmal in
// den Arbeitsspeicher. Mit DEV=1 wird bei jedem Aufruf neu gelesen.
import { createHash } from 'node:crypto';
import fs from 'node:fs';
import path from 'node:path';
import { escapeHtml } from './util.js';
const HTML = 'text/html; charset=utf-8';
const TYPES = {
'.css': 'text/css; charset=utf-8',
'.js': 'text/javascript; charset=utf-8',
'.svg': 'image/svg+xml',
'.txt': 'text/plain; charset=utf-8',
'.png': 'image/png',
'.ico': 'image/x-icon',
'.webmanifest': 'application/manifest+json',
};
function entry(body, type) {
const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body, 'utf8');
const etag = `"${createHash('sha256').update(buffer).digest('base64url').slice(0, 16)}"`;
return { body: buffer, type, etag };
}
/** Ersetzt {{name}} durch den passenden Wert; Unbekanntes bleibt stehen. */
function render(template, vars) {
return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (match, key) =>
Object.hasOwn(vars, key) ? vars[key] : match,
);
}
export class Pages {
#pages = new Map();
#assets = new Map();
constructor(config) {
this.config = config;
this.reload();
}
reload() {
const pagesDir = path.join(this.config.rootDir, 'pages');
const publicDir = path.join(this.config.rootDir, 'public');
const read = (...parts) => fs.readFileSync(path.join(pagesDir, ...parts), 'utf8');
const vars = { siteName: escapeHtml(this.config.siteName) };
for (const file of fs.readdirSync(path.join(pagesDir, 'partials'))) {
if (file.endsWith('.html')) vars[file.slice(0, -5)] = render(read('partials', file), vars);
}
const pages = new Map();
for (const file of fs.readdirSync(pagesDir)) {
if (!file.endsWith('.html')) continue;
pages.set(file.slice(0, -5), entry(render(read(file), { ...vars, transferState: 'loading' }), HTML));
}
// Dieselbe Seite für Links, die es nicht (mehr) gibt.
pages.set('download-missing', entry(render(read('download.html'), { ...vars, transferState: 'missing' }), HTML));
const assets = new Map();
const walk = (dir, prefix) => {
for (const item of fs.readdirSync(dir, { withFileTypes: true })) {
if (item.name.startsWith('.')) continue;
const full = path.join(dir, item.name);
if (item.isDirectory()) walk(full, `${prefix}${item.name}/`);
else if (item.isFile() && TYPES[path.extname(item.name)]) {
assets.set(`${prefix}${item.name}`, entry(fs.readFileSync(full), TYPES[path.extname(item.name)]));
}
}
};
walk(publicDir, '/');
this.#pages = pages;
this.#assets = assets;
}
page(name) {
if (this.config.dev) this.reload();
return this.#pages.get(name);
}
asset(pathname) {
if (this.config.dev) this.reload();
return this.#assets.get(pathname);
}
}
+368
View File
@@ -0,0 +1,368 @@
// Ablage der Transfers auf der Festplatte.
//
// <DATA_DIR>/transfers/<kennung>/meta.json Metadaten
// <DATA_DIR>/transfers/<kennung>/0, 1, ... die Dateien, nach Position benannt
//
// Die Namen der Nutzer landen nie im Dateisystem, nur in meta.json.
import fs from 'node:fs';
import fsp from 'node:fs/promises';
import path from 'node:path';
import { Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { HttpError, ID_PATTERN, randomId, randomToken, sha256 } from './util.js';
const META = 'meta.json';
const DAY_MS = 86_400_000;
export class Store {
#transfers = new Map();
constructor(config, log = () => {}) {
this.config = config;
this.log = log;
this.dir = path.join(config.dataDir, 'transfers');
}
/** Legt den Datenordner an und liest vorhandene Transfers ein. */
async init() {
await fsp.mkdir(this.dir, { recursive: true, mode: 0o700 });
for (const entry of await fsp.readdir(this.dir, { withFileTypes: true })) {
if (!entry.isDirectory() || !ID_PATTERN.test(entry.name)) continue;
try {
const transfer = await this.#load(entry.name);
this.#transfers.set(transfer.id, transfer);
} catch (err) {
this.log(`Warnung: Ordner ${entry.name} übersprungen (${err.message})`);
}
}
}
get size() {
return this.#transfers.size;
}
list() {
return [...this.#transfers.values()];
}
dirPath(id) {
return path.join(this.dir, id);
}
filePath(transfer, index) {
return path.join(this.dir, transfer.id, String(index));
}
/** Transfer in beliebigem Zustand; abgelaufene gelten als nicht vorhanden. */
get(id, now = Date.now()) {
const transfer = this.#transfers.get(id);
if (!transfer) return undefined;
if (transfer.state === 'ready' && now >= transfer.expiresAt) return undefined;
return transfer;
}
/** Nur fertig hochgeladene Transfers – das, was Besucher sehen dürfen. */
getReady(id, now = Date.now()) {
const transfer = this.get(id, now);
return transfer && transfer.state === 'ready' ? transfer : undefined;
}
reservedBytes() {
let sum = 0;
for (const t of this.#transfers.values()) sum += t.totalBytes;
return sum;
}
/** Bytes, die laufende Uploads noch schreiben werden. */
#pendingBytes() {
let sum = 0;
for (const t of this.#transfers.values()) {
if (t.state !== 'uploading') continue;
for (const f of t.files) sum += f.size - f.received;
}
return sum;
}
async create({ files, expiryDays, codeLabel = null }) {
const totalBytes = files.reduce((sum, f) => sum + f.size, 0);
let free = Infinity;
try {
const stat = await fsp.statfs(this.dir);
free = stat.bavail * stat.bsize;
} catch {
// Ohne Angabe zum freien Platz gilt nur das eigene Kontingent.
}
// Ab hier ohne Unterbrechung prüfen und reservieren, damit gleichzeitige
// Anfragen das Kontingent nicht gemeinsam überziehen.
const cfg = this.config;
if (
this.#transfers.size >= cfg.maxTransfers ||
this.reservedBytes() + totalBytes > cfg.storageQuotaBytes ||
free - this.#pendingBytes() - totalBytes < cfg.minFreeBytes
) {
throw new HttpError(507, 'storage_full');
}
let id = randomId();
while (this.#transfers.has(id)) id = randomId();
const uploadToken = randomToken();
const deleteToken = randomToken();
const now = Date.now();
const transfer = {
id,
state: 'uploading',
createdAt: now,
finishedAt: null,
expiresAt: null,
expiryDays,
codeLabel,
uploadTokenHash: sha256(uploadToken),
deleteTokenHash: sha256(deleteToken),
files: files.map((f) => ({ name: f.name, size: f.size, received: 0, busy: false })),
totalBytes,
lastActivity: now,
finishing: null,
};
this.#transfers.set(id, transfer);
let dirCreated = false;
try {
await fsp.mkdir(this.dirPath(id), { mode: 0o700 });
dirCreated = true;
for (let i = 0; i < transfer.files.length; i++) {
await fsp.writeFile(this.filePath(transfer, i), '', { mode: 0o600, flag: 'wx' });
}
await this.#saveMeta(transfer);
} catch (err) {
this.#transfers.delete(id);
// Nur aufräumen, was hier selbst angelegt wurde.
if (dirCreated) await fsp.rm(this.dirPath(id), { recursive: true, force: true }).catch(() => {});
throw err;
}
return { transfer, uploadToken, deleteToken };
}
/**
* Schreibt ein Stück einer Datei. `offset` muss genau dort ansetzen, wo die
* Datei bisher endet; so lässt sich ein abgebrochenes Stück gefahrlos
* wiederholen. Gibt den neuen Stand zurück.
*/
async writeChunk(transfer, index, offset, source, maxBytes) {
const file = transfer.files[index];
if (!file) throw new HttpError(404, 'not_found');
if (transfer.state !== 'uploading' || transfer.finishing) throw new HttpError(409, 'not_uploading');
if (file.busy) throw new HttpError(409, 'busy');
if (offset !== file.received) throw new HttpError(409, 'offset_mismatch', { received: file.received });
// Eine schon abgerissene Verbindung würde nie ein Ende melden.
if (source.destroyed) throw new Error('Übertragung abgebrochen');
const limit = Math.min(maxBytes, file.size - offset);
let count = 0;
const counter = new Transform({
transform(chunk, _encoding, done) {
count += chunk.length;
if (count > limit) done(new HttpError(413, 'chunk_too_large'));
else done(null, chunk);
},
});
file.busy = true;
const target = fs.createWriteStream(this.filePath(transfer, index), { flags: 'r+', start: offset });
// Die Quelle (die HTTP-Anfrage) wird bei einem Fehler bewusst nicht
// zerstört, damit der Server dem Browser noch antworten kann.
const onClose = () => {
if (!source.readableEnded) counter.destroy(new Error('Übertragung abgebrochen'));
};
source.once('close', onClose);
source.pipe(counter);
try {
await pipeline(counter, target);
} catch (err) {
source.unpipe(counter);
if (err.code === 'ENOSPC') throw new HttpError(507, 'storage_full');
if (err.code === 'ENOENT') throw new HttpError(404, 'not_found');
throw err;
} finally {
source.off('close', onClose);
file.busy = false;
}
// Wurde der Transfer währenddessen gelöscht (Abbruch), ist das Stück verloren.
if (this.#transfers.get(transfer.id) !== transfer) throw new HttpError(404, 'not_found');
file.received = offset + count;
transfer.lastActivity = Date.now();
return file.received;
}
/** Schließt den Upload ab; erst danach ist der Transfer abrufbar. */
finish(transfer) {
if (transfer.state === 'ready') return Promise.resolve(transfer);
transfer.finishing ??= this.#finish(transfer).finally(() => {
transfer.finishing = null;
});
return transfer.finishing;
}
async #finish(transfer) {
for (const file of transfer.files) {
if (file.busy) throw new HttpError(409, 'busy');
if (file.received !== file.size) throw new HttpError(409, 'incomplete');
}
// Daten sicher auf die Platte bringen, bevor der Link gültig wird.
for (let i = 0; i < transfer.files.length; i++) {
let handle;
try {
handle = await fsp.open(this.filePath(transfer, i), 'r+');
const stat = await handle.stat();
if (stat.size !== transfer.files[i].size) throw new HttpError(409, 'incomplete');
await handle.sync();
} catch (err) {
if (err.code === 'ENOENT') throw new HttpError(404, 'not_found');
throw err;
} finally {
await handle?.close();
}
}
if (this.#transfers.get(transfer.id) !== transfer) throw new HttpError(404, 'not_found');
const now = Date.now();
transfer.state = 'ready';
transfer.finishedAt = now;
transfer.expiresAt = now + transfer.expiryDays * DAY_MS;
try {
await this.#saveMeta(transfer);
} catch (err) {
transfer.state = 'uploading';
transfer.finishedAt = null;
transfer.expiresAt = null;
if (err.code === 'ENOENT') throw new HttpError(404, 'not_found');
throw err;
}
return transfer;
}
async remove(id) {
const transfer = this.#transfers.get(id);
if (!transfer) return false;
// Erst aus der Liste nehmen, damit kein neuer Download mehr beginnt.
this.#transfers.delete(id);
try {
await fsp.rm(this.dirPath(id), { recursive: true, force: true });
} catch (err) {
// Bleibt in der Liste, damit das Aufräumen es später erneut versucht.
this.#transfers.set(id, transfer);
throw err;
}
return true;
}
/**
* Räumt auf: abgelaufene Transfers, liegen gebliebene Uploads und Einträge,
* deren Ordner von Hand gelöscht wurde. Gibt die Zahl der entfernten zurück.
*/
async sweep(now = Date.now()) {
let removed = 0;
for (const transfer of this.list()) {
let reason = null;
if (transfer.state === 'ready' && now >= transfer.expiresAt) {
reason = 'Frist abgelaufen';
} else if (transfer.state === 'uploading' && now - transfer.lastActivity > this.config.staleUploadMs) {
reason = 'Upload nicht beendet';
} else if (!(await exists(this.dirPath(transfer.id)))) {
reason = 'Ordner fehlt';
}
if (!reason) continue;
try {
if (await this.remove(transfer.id)) {
removed += 1;
this.log(`Transfer ${transfer.id} entfernt (${reason})`);
}
} catch (err) {
this.log(`Warnung: Transfer ${transfer.id} ließ sich nicht löschen (${err.message})`);
}
}
return removed;
}
async #saveMeta(transfer) {
const meta = {
v: 1,
id: transfer.id,
state: transfer.state,
createdAt: transfer.createdAt,
finishedAt: transfer.finishedAt,
expiresAt: transfer.expiresAt,
expiryDays: transfer.expiryDays,
codeLabel: transfer.codeLabel,
uploadTokenHash: transfer.uploadTokenHash,
deleteTokenHash: transfer.deleteTokenHash,
files: transfer.files.map(({ name, size }) => ({ name, size })),
};
const dir = this.dirPath(transfer.id);
const tmp = path.join(dir, `${META}.tmp`);
const handle = await fsp.open(tmp, 'w', 0o600);
try {
await handle.writeFile(JSON.stringify(meta, null, 2));
await handle.sync();
} finally {
await handle.close();
}
await fsp.rename(tmp, path.join(dir, META));
}
async #load(id) {
const meta = JSON.parse(await fsp.readFile(path.join(this.dirPath(id), META), 'utf8'));
const valid =
meta?.v === 1 &&
meta.id === id &&
(meta.state === 'uploading' || meta.state === 'ready') &&
Number.isSafeInteger(meta.createdAt) &&
Number.isSafeInteger(meta.expiryDays) &&
(meta.state !== 'ready' || Number.isSafeInteger(meta.expiresAt)) &&
typeof meta.uploadTokenHash === 'string' &&
typeof meta.deleteTokenHash === 'string' &&
Array.isArray(meta.files) &&
meta.files.length > 0 &&
meta.files.every((f) => typeof f?.name === 'string' && Number.isSafeInteger(f.size) && f.size >= 0);
if (!valid) throw new Error('meta.json ist unvollständig');
const transfer = {
id,
state: meta.state,
createdAt: meta.createdAt,
finishedAt: meta.finishedAt ?? null,
expiresAt: meta.expiresAt ?? null,
expiryDays: meta.expiryDays,
codeLabel: meta.codeLabel ?? null,
uploadTokenHash: meta.uploadTokenHash,
deleteTokenHash: meta.deleteTokenHash,
files: [],
totalBytes: 0,
lastActivity: Date.now(),
finishing: null,
};
for (let i = 0; i < meta.files.length; i++) {
const { name, size } = meta.files[i];
let received = size;
if (meta.state === 'uploading') {
// Nach einem Neustart zählt, was tatsächlich auf der Platte liegt.
const stat = await fsp.stat(path.join(this.dirPath(id), String(i)));
received = Math.min(stat.size, size);
}
transfer.files.push({ name, size, received, busy: false });
transfer.totalBytes += size;
}
return transfer;
}
}
async function exists(target) {
try {
await fsp.access(target);
return true;
} catch {
return false;
}
}
+128
View File
@@ -0,0 +1,128 @@
// Kleine Helfer ohne eigenen Zustand.
import { createHash, randomBytes, randomInt, timingSafeEqual } from 'node:crypto';
import net from 'node:net';
/** Fehler, der als HTTP-Antwort beim Client ankommt. */
export class HttpError extends Error {
constructor(status, code, extra = {}) {
super(code);
this.name = 'HttpError';
this.status = status;
this.code = code;
this.extra = extra;
}
}
// Kennung eines Transfers: 10 Zeichen aus 31 gut unterscheidbaren
// (ohne 0, 1, i, l, o). Das sind rund 8 * 10^14 Möglichkeiten.
const ID_ALPHABET = '23456789abcdefghjkmnpqrstuvwxyz';
export const ID_LENGTH = 10;
export const ID_PATTERN = /^[2-9a-hjkmnp-z]{10}$/;
export function randomId() {
let id = '';
for (let i = 0; i < ID_LENGTH; i++) id += ID_ALPHABET[randomInt(ID_ALPHABET.length)];
return id;
}
export function randomToken() {
return randomBytes(32).toString('base64url');
}
export function sha256(text) {
return createHash('sha256').update(String(text), 'utf8').digest('hex');
}
/** Vergleicht zwei Hex-Hashes, ohne über die Laufzeit etwas zu verraten. */
export function hashEquals(aHex, bHex) {
const a = Buffer.from(String(aHex), 'hex');
const b = Buffer.from(String(bHex), 'hex');
return a.length > 0 && a.length === b.length && timingSafeEqual(a, b);
}
/**
* Schlüssel für die Zugriffsbegrenzung: IPv4-Adressen einzeln, IPv6-Adressen
* als /64-Netz (ein Anschluss hat dort meist ein ganzes /64 zur Verfügung).
*/
export function ipKey(raw) {
let ip = String(raw ?? '').trim();
const zone = ip.indexOf('%');
if (zone !== -1) ip = ip.slice(0, zone);
if (/^::ffff:/i.test(ip) && net.isIPv4(ip.slice(7))) ip = ip.slice(7);
if (net.isIPv4(ip)) return ip;
if (!net.isIPv6(ip)) return 'unbekannt';
// Eine eingebettete IPv4-Adresse am Ende zählt als zwei Gruppen.
const expandV4 = (groups) =>
groups.flatMap((g) => (g.includes('.') ? ['0', '0'] : [g]));
let groups;
if (ip.includes('::')) {
const [head, tail] = ip.split('::');
const left = expandV4(head ? head.split(':') : []);
const right = expandV4(tail ? tail.split(':') : []);
const fill = Array(Math.max(0, 8 - left.length - right.length)).fill('0');
groups = [...left, ...fill, ...right];
} else {
groups = expandV4(ip.split(':'));
}
const prefix = groups.slice(0, 4).map((g) => (parseInt(g, 16) || 0).toString(16));
return `${prefix.join(':')}::/64`;
}
const MAX_NAME_BYTES = 200;
function truncateBytes(text, maxBytes) {
let bytes = 0;
let out = '';
for (const ch of text) {
const size = Buffer.byteLength(ch);
if (bytes + size > maxBytes) break;
bytes += size;
out += ch;
}
return out;
}
/**
* Macht aus einem vom Browser gemeldeten Dateinamen einen harmlosen Anzeigenamen.
* Der Name wird nie als Pfad auf dem Server benutzt; er steht nur in den
* Metadaten und im Download-Header.
*/
export function sanitizeName(input) {
let name = String(input ?? '').toWellFormed().normalize('NFC');
name = name.split(/[/\\]/).pop();
name = name.replace(/\s+/g, ' ');
// Steuerzeichen und unsichtbare Richtungswechsel entfernen (damit lässt sich
// sonst die Dateiendung optisch verstecken).
name = name.replace(/[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069\ufeff]/g, '');
name = name.trim();
if (name === '' || name === '.' || name === '..') return 'datei';
if (Buffer.byteLength(name) > MAX_NAME_BYTES) {
const dot = name.lastIndexOf('.');
const ext = dot > 0 && name.length - dot <= 16 ? name.slice(dot) : '';
const stem = ext ? name.slice(0, dot) : name;
name = truncateBytes(stem, MAX_NAME_BYTES - Buffer.byteLength(ext)) + ext || 'datei';
}
return name;
}
/** Content-Disposition-Header nach RFC 6266: ASCII-Ersatzname plus UTF-8-Name. */
export function contentDisposition(name) {
const ascii = name.replace(/[^\x20-\x7e]/g, '_').replace(/["\\%]/g, '_');
const utf8 = encodeURIComponent(name).replace(
/[!'()*]/g,
(c) => '%' + c.charCodeAt(0).toString(16).toUpperCase(),
);
return `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
}
export function escapeHtml(text) {
return String(text).replace(
/[&<>"']/g,
(c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c],
);
}
export function isPlainObject(value) {
return typeof value === 'object' && value !== null && !Array.isArray(value);
}
+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);
});
+92
View File
@@ -0,0 +1,92 @@
#!/usr/bin/env node
// Verwaltung von der Kommandozeile.
//
// node tools/transfers.js list alle Transfers anzeigen
// node tools/transfers.js delete <kennung> einen Transfer sofort löschen
//
// Im Docker-Betrieb:
// sudo docker compose exec filetransfer node tools/transfers.js list
//
// Der laufende Dienst bemerkt eine Löschung spätestens nach einer Minute.
import fs from 'node:fs/promises';
import path from 'node:path';
import { loadConfig } from '../src/config.js';
import { ID_PATTERN } from '../src/util.js';
const rootDir = path.resolve(import.meta.dirname, '..');
try {
process.loadEnvFile(path.join(rootDir, '.env'));
} catch (err) {
if (err.code !== 'ENOENT') throw err;
}
const transfersDir = path.join(loadConfig(process.env, { rootDir }).dataDir, 'transfers');
function formatBytes(bytes) {
const units = ['B', 'KB', 'MB', 'GB', 'TB'];
let value = bytes;
let unit = 0;
while (value >= 1024 && unit < units.length - 1) {
value /= 1024;
unit += 1;
}
return `${unit === 0 ? value : value.toFixed(1)} ${units[unit]}`;
}
const formatTime = (timestamp) => (timestamp ? new Date(timestamp).toLocaleString('sv-SE').slice(0, 16) : '–');
async function list() {
let names = [];
try {
names = await fs.readdir(transfersDir);
} catch (err) {
if (err.code !== 'ENOENT') throw err;
}
const rows = [];
for (const id of names.filter((name) => ID_PATTERN.test(name)).sort()) {
try {
const meta = JSON.parse(await fs.readFile(path.join(transfersDir, id, 'meta.json'), 'utf8'));
const bytes = meta.files.reduce((sum, file) => sum + file.size, 0);
const expired = meta.state === 'ready' && Date.now() >= meta.expiresAt;
rows.push({
Kennung: id,
Zustand: expired ? 'abgelaufen' : meta.state === 'ready' ? 'fertig' : 'Upload läuft',
Angelegt: formatTime(meta.createdAt),
'Gültig bis': formatTime(meta.expiresAt),
Code: meta.codeLabel ?? '–',
Größe: formatBytes(bytes),
Dateien: meta.files.length === 1 ? meta.files[0].name : `${meta.files[0].name} (+${meta.files.length - 1})`,
});
} catch {
rows.push({ Kennung: id, Zustand: 'meta.json nicht lesbar' });
}
}
if (rows.length === 0) {
console.log('Keine Transfers vorhanden.');
return;
}
console.table(rows);
}
async function remove(id) {
if (!ID_PATTERN.test(id ?? '')) {
console.error('Bitte eine gültige Kennung angeben (die 10 Zeichen hinter /d/ im Link).');
process.exit(1);
}
const dir = path.join(transfersDir, id);
try {
await fs.access(dir);
} catch {
console.error(`Einen Transfer ${id} gibt es nicht.`);
process.exit(1);
}
await fs.rm(dir, { recursive: true, force: true });
console.log(`Transfer ${id} gelöscht.`);
}
const [command, argument] = process.argv.slice(2);
if (command === 'list') await list();
else if (command === 'delete') await remove(argument?.toLowerCase());
else {
console.log('Aufruf:\n node tools/transfers.js list\n node tools/transfers.js delete <kennung>');
process.exit(command ? 1 : 0);
}