diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..23758da --- /dev/null +++ b/.dockerignore @@ -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 diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..b762335 --- /dev/null +++ b/.env.example @@ -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= diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..001ff6d --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +# Hochgeladene Dateien und persönliche Einstellungen gehören nicht ins Repository +/data/ +.env +node_modules/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..fc60fbe --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/README.md b/README.md index 64eb9fb..17e6acb 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,160 @@ # 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= + APP_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 ` | + +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//`: 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//files/?offset=` ü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//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. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..73049b7 --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/package.json b/package.json new file mode 100644 index 0000000..0362c14 --- /dev/null +++ b/package.json @@ -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\"" + } +} diff --git a/pages/404.html b/pages/404.html new file mode 100644 index 0000000..6168a21 --- /dev/null +++ b/pages/404.html @@ -0,0 +1,30 @@ + + + +{{head}} +Seite nicht gefunden – {{siteName}} + + +{{header}} +
+
+

+ Seite nicht gefunden + Page not found +

+

+ Unter dieser Adresse gibt es nichts. + There is nothing at this address. +

+

+ + Zur Startseite + Go to the start page + +

+
+
+{{footer}} + + + diff --git a/pages/download.html b/pages/download.html new file mode 100644 index 0000000..465cbb8 --- /dev/null +++ b/pages/download.html @@ -0,0 +1,72 @@ + + + +{{head}} +Dateien herunterladen – {{siteName}} + + +{{header}} +
+ +
+

+ Wird geladen … + Loading … +

+ +
+ +
+
+

+

+
+
+
    +
    +

    + Öffne Dateien nur, wenn du der Person vertraust, die dir den Link geschickt hat. + Only open files if you trust the person who sent you the link. +

    +
    + +
    +

    + Diesen Link gibt es nicht mehr + This link no longer exists +

    +

    + Die Dateien sind abgelaufen oder wurden gelöscht. Vielleicht wurde der Link auch nicht vollständig kopiert. + The files have expired or were deleted. The link may also have been copied incompletely. +

    +

    + + Zur Startseite + Go to the start page + +

    +
    + +
    +

    + Das hat nicht geklappt + That did not work +

    +

    +

    + +

    +
    +
    +{{footer}} + + + diff --git a/pages/index.html b/pages/index.html new file mode 100644 index 0000000..779b688 --- /dev/null +++ b/pages/index.html @@ -0,0 +1,187 @@ + + + +{{head}} +Dateien teilen – {{siteName}} + + +{{header}} +
    +
    +

    + Dateien teilen + Share files +

    +

    + Lade Dateien hoch und gib den Link weiter. Nach Ablauf der Frist werden sie automatisch gelöscht. + Upload files and pass on the link. They are deleted automatically once the time is up. +

    +
    + + + +
    + +
    +
    + +

    + Dateien hierher ziehen + Drag files here +

    +

    + oder + or +

    + + +

    +
    + + + +
    +
    + + +
    +
    + + + +
    +
    +

    + Zum Hochladen brauchst du einen Upload-Code. Du bekommst ihn von der Person, die diese Seite betreibt. + You need an upload code to upload. Ask the person who runs this site for one. +

    + + + + +
    + + + + + + + + + +
    + + +
    +{{footer}} + + + diff --git a/pages/partials/footer.html b/pages/partials/footer.html new file mode 100644 index 0000000..05f9f60 --- /dev/null +++ b/pages/partials/footer.html @@ -0,0 +1,6 @@ +
    +

    + Privater Dateitransfer + Private file transfer +

    +
    diff --git a/pages/partials/head.html b/pages/partials/head.html new file mode 100644 index 0000000..281daa7 --- /dev/null +++ b/pages/partials/head.html @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/pages/partials/header.html b/pages/partials/header.html new file mode 100644 index 0000000..ae066a5 --- /dev/null +++ b/pages/partials/header.html @@ -0,0 +1,7 @@ + diff --git a/public/css/style.css b/public/css/style.css new file mode 100644 index 0000000..cc852e0 --- /dev/null +++ b/public/css/style.css @@ -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 -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; + } +} diff --git a/public/favicon.svg b/public/favicon.svg new file mode 100644 index 0000000..3fa09e7 --- /dev/null +++ b/public/favicon.svg @@ -0,0 +1,4 @@ + + + + diff --git a/public/js/common.js b/public/js/common.js new file mode 100644 index 0000000..fcef20b --- /dev/null +++ b/public/js/common.js @@ -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; +} diff --git a/public/js/download.js b/public/js/download.js new file mode 100644 index 0000000..a540788 --- /dev/null +++ b/public/js/download.js @@ -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(); diff --git a/public/js/lang.js b/public/js/lang.js new file mode 100644 index 0000000..09e221a --- /dev/null +++ b/public/js/lang.js @@ -0,0 +1,15 @@ +// Stellt die Sprache ein, bevor die Seite gezeichnet wird (deshalb ohne "defer" +// im ). 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; +})(); diff --git a/public/js/upload.js b/public/js/upload.js new file mode 100644 index 0000000..6dc3bad --- /dev/null +++ b/public/js/upload.js @@ -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(); diff --git a/public/robots.txt b/public/robots.txt new file mode 100644 index 0000000..6e3bb44 --- /dev/null +++ b/public/robots.txt @@ -0,0 +1,3 @@ +# Private Seite: Suchmaschinen sollen hier nichts erfassen. +User-agent: * +Disallow: / diff --git a/server.js b/server.js new file mode 100644 index 0000000..e9236c1 --- /dev/null +++ b/server.js @@ -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); + }); +} diff --git a/src/app.js b/src/app.js new file mode 100644 index 0000000..d87bc1d --- /dev/null +++ b/src/app.js @@ -0,0 +1,563 @@ +// HTTP-Server: Seiten, Schnittstelle für den Upload und die Downloads. +// +// GET / Upload-Seite +// GET /d/ Download-Seite +// GET /d// 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/ Dateiliste eines fertigen Transfers +// DELETE /api/transfers/ Transfer löschen (Lösch-Token) +// GET /api/transfers//upload Stand des Uploads (Upload-Token) +// PUT /api/transfers//files/?offset= ein Stück hochladen +// POST /api/transfers//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(); + }); + }, + }; +} diff --git a/src/config.js b/src/config.js new file mode 100644 index 0000000..50eff63 --- /dev/null +++ b/src/config.js @@ -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'), + }; +} diff --git a/src/limiter.js b/src/limiter.js new file mode 100644 index 0000000..9c6e19b --- /dev/null +++ b/src/limiter.js @@ -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; + } + } +} diff --git a/src/pages.js b/src/pages.js new file mode 100644 index 0000000..0bbb1d2 --- /dev/null +++ b/src/pages.js @@ -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); + } +} diff --git a/src/store.js b/src/store.js new file mode 100644 index 0000000..552a397 --- /dev/null +++ b/src/store.js @@ -0,0 +1,368 @@ +// Ablage der Transfers auf der Festplatte. +// +// /transfers//meta.json Metadaten +// /transfers//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; + } +} diff --git a/src/util.js b/src/util.js new file mode 100644 index 0000000..faf30f0 --- /dev/null +++ b/src/util.js @@ -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) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' })[c], + ); +} + +export function isPlainObject(value) { + return typeof value === 'object' && value !== null && !Array.isArray(value); +} diff --git a/test/api.test.js b/test/api.test.js new file mode 100644 index 0000000..fe40169 --- /dev/null +++ b/test/api.test.js @@ -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 & ' }); + t.after(() => ctx.stop()); + + const home = await fetch(`${ctx.base}/`); + assert.equal(home.status, 200); + assert.match(home.headers.get('content-type'), /^text\/html/); + const html = await home.text(); + assert.ok(html.includes('Test & <Seite>'), 'Seitenname wird maskiert eingesetzt'); + assert.equal(html.includes('{{'), false, 'keine Platzhalter übrig'); + + // Schutz-Header auf jeder Antwort + assert.match(home.headers.get('content-security-policy'), /default-src 'none'/); + assert.equal(home.headers.get('x-content-type-options'), 'nosniff'); + assert.equal(home.headers.get('x-frame-options'), 'DENY'); + assert.equal(home.headers.get('referrer-policy'), 'no-referrer'); + + // Unveränderte Seite: 304 statt erneuter Übertragung + const again = await fetch(`${ctx.base}/`, { headers: { 'If-None-Match': home.headers.get('etag') } }); + assert.equal(again.status, 304); + + const css = await fetch(`${ctx.base}/css/style.css`); + assert.equal(css.status, 200); + assert.match(css.headers.get('content-type'), /^text\/css/); + const js = await fetch(`${ctx.base}/js/upload.js`); + assert.match(js.headers.get('content-type'), /^text\/javascript/); + assert.equal((await fetch(`${ctx.base}/favicon.svg`)).headers.get('content-type'), 'image/svg+xml'); + assert.match(await (await fetch(`${ctx.base}/robots.txt`)).text(), /Disallow: \//); + + const head = await fetch(`${ctx.base}/`, { method: 'HEAD' }); + assert.equal(head.status, 200); + assert.equal(await head.text(), ''); + + const missing = await fetch(`${ctx.base}/gibt-es-nicht`); + assert.equal(missing.status, 404); + assert.match(await missing.text(), /Seite nicht gefunden/); + + const apiMissing = await fetch(`${ctx.base}/api/gibt-es-nicht`); + assert.equal(apiMissing.status, 404); + assert.deepEqual(await apiMissing.json(), { error: 'not_found' }); + + const wrongMethod = await fetch(`${ctx.base}/`, { method: 'POST' }); + assert.equal(wrongMethod.status, 405); + assert.equal(wrongMethod.headers.get('allow'), 'GET, HEAD'); + + assert.equal((await fetch(`${ctx.base}/healthz`)).status, 200); +}); + +test('Pfade außerhalb von public/ sind nicht erreichbar', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + for (const target of [ + '/../server.js', + '/css/../../server.js', + '/css/%2e%2e/%2e%2e/server.js', + '/..%2f.env', + '/.env', + '/server.js', + '/src/app.js', + '/pages/index.html', + '/index.html', + '//etc/passwd', + ]) { + const res = await rawRequest(ctx.port, { method: 'GET', path: target }); + assert.equal(res.status, 404, target); + } +}); + +test('Einstellungen für die Oberfläche', async (t) => { + const ctx = await startApp({ MAX_TRANSFER_SIZE: '10MB', MAX_FILES: '5', EXPIRY_DAYS: '1,3' }); + t.after(() => ctx.stop()); + const res = await fetch(`${ctx.base}/api/config`); + assert.equal(res.headers.get('cache-control'), 'no-store'); + assert.deepEqual(await res.json(), { + uploadsEnabled: true, + codeRequired: true, + maxTransferBytes: 10 * 1024 ** 2, + maxFiles: 5, + expiryDays: [1, 3], + defaultExpiryDays: 1, + }); +}); + +test('Hochladen in Stücken, abrufen und herunterladen', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + + const files = [ + randomFile('Urlaub 2026 – Ägäis (1).jpg', 700_000), // drei Stücke + randomFile('leer.txt', 0), + randomFile('../../boese/pfad.bin', 1234), + ]; + const transfer = await uploadAll(ctx.base, files, { expiryDays: 1 }); + assert.match(transfer.id, /^[2-9a-hjkmnp-z]{10}$/); + const expectedExpiry = Date.now() + 86_400_000; + assert.ok(Math.abs(transfer.expiresAt - expectedExpiry) < 10_000); + + const info = await (await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).json(); + assert.equal(info.id, transfer.id); + assert.equal(info.totalBytes, 701_234); + assert.deepEqual(info.files, [ + { name: 'Urlaub 2026 – Ägäis (1).jpg', size: 700_000 }, + { name: 'leer.txt', size: 0 }, + { name: 'pfad.bin', size: 1234 }, + ]); + assert.equal('deleteTokenHash' in info || 'uploadTokenHash' in info, false); + + // Auf der Platte liegen nur Nummern, keine Namen der Nutzer + const stored = (await fs.readdir(path.join(ctx.dataDir, 'transfers', transfer.id))).sort(); + assert.deepEqual(stored, ['0', '1', '2', 'meta.json']); + + for (let index = 0; index < files.length; index++) { + const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`); + assert.equal(res.status, 200); + assert.equal(res.headers.get('content-type'), 'application/octet-stream'); + assert.equal(res.headers.get('x-content-type-options'), 'nosniff'); + assert.match(res.headers.get('content-security-policy'), /sandbox/); + assert.match(res.headers.get('content-disposition'), /^attachment; /); + assert.equal(res.headers.get('content-length'), String(files[index].data.length)); + assert.deepEqual(Buffer.from(await res.arrayBuffer()), files[index].data); + } + const disposition = (await fetch(`${ctx.base}/d/${transfer.id}/0`, { method: 'HEAD' })).headers.get( + 'content-disposition', + ); + assert.ok(disposition.includes("filename*=UTF-8''Urlaub%202026%20%E2%80%93%20%C3%84g%C3%A4is%20%281%29.jpg")); + + // Teilabrufe (zum Fortsetzen abgebrochener Downloads) + const data = files[0].data; + const part = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=100-199' } }); + assert.equal(part.status, 206); + assert.equal(part.headers.get('content-range'), `bytes 100-199/${data.length}`); + assert.deepEqual(Buffer.from(await part.arrayBuffer()), data.subarray(100, 200)); + + const tail = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=-50' } }); + assert.equal(tail.status, 206); + assert.deepEqual(Buffer.from(await tail.arrayBuffer()), data.subarray(data.length - 50)); + + const rest = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=699990-' } }); + assert.equal(rest.status, 206); + assert.deepEqual(Buffer.from(await rest.arrayBuffer()), data.subarray(699_990)); + + const beyond = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=700000-' } }); + assert.equal(beyond.status, 416); + assert.equal(beyond.headers.get('content-range'), `bytes */${data.length}`); + + const stale = await fetch(`${ctx.base}/d/${transfer.id}/0`, { + headers: { Range: 'bytes=0-9', 'If-Range': '"anderer-stand"' }, + }); + assert.equal(stale.status, 200, 'veralteter If-Range liefert die ganze Datei'); + await stale.arrayBuffer(); + + // Datei-Nummern außerhalb der Liste + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/3`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/meta.json`)).status, 404); + + // Download-Seite; die Kennung gilt auch in Großbuchstaben + const page = await fetch(`${ctx.base}/d/${transfer.id}`); + assert.equal(page.status, 200); + assert.match(await page.text(), /data-state="loading"/); + assert.equal(page.headers.get('x-robots-tag'), 'noindex, nofollow'); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id.toUpperCase()}`)).status, 200); + assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id.toUpperCase()}`)).status, 200); + + assert.ok(ctx.logs.some((line) => line.includes(`Transfer ${transfer.id} angelegt`) && line.includes('"test"'))); + assert.equal(ctx.logs.some((line) => line.includes(CODE)), false, 'der Code selbst steht nie im Protokoll'); +}); + +test('Ohne gültigen Upload-Code wird nichts angelegt', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('a.txt', 10); + + const none = await createTransfer(ctx.base, [file], { code: undefined }); + assert.equal(none.res.status, 401); + assert.equal(none.body.error, 'code_required'); + + const wrong = await createTransfer(ctx.base, [file], { code: 'falsch' }); + assert.equal(wrong.res.status, 401); + assert.equal(wrong.body.error, 'code_invalid'); + + const padded = await createTransfer(ctx.base, [file], { code: ` ${CODE}\n` }); + assert.equal(padded.res.status, 201, 'Leerzeichen um den Code stören nicht'); + + assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 1); +}); + +test('Zu viele falsche Codes sperren die Adresse vorübergehend', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('a.txt', 10); + for (let i = 0; i < 10; i++) { + assert.equal((await createTransfer(ctx.base, [file], { code: `falsch-${i}` })).res.status, 401); + } + const blocked = await createTransfer(ctx.base, [file]); + assert.equal(blocked.res.status, 429); + assert.equal(blocked.body.error, 'rate_limited'); + assert.ok(Number(blocked.res.headers.get('retry-after')) > 0); + assert.equal(blocked.body.retryAfter, Number(blocked.res.headers.get('retry-after'))); +}); + +test('Hinter einem Proxy zählt die weitergereichte Adresse', async (t) => { + const direct = await startApp(); + const proxied = await startApp({ TRUST_PROXY: '1' }); + t.after(() => Promise.all([direct.stop(), proxied.stop()])); + const file = randomFile('a.txt', 10); + + // Mit TRUST_PROXY wird je weitergereichter Adresse gezählt … + for (let i = 0; i < 10; i++) { + await createTransfer(proxied.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': '198.51.100.1' }); + } + const sameIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.1' }); + assert.equal(sameIp.res.status, 429); + const otherIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.2' }); + assert.equal(otherIp.res.status, 201); + // … und nur der letzte Eintrag gilt, den der eigene Proxy angehängt hat. + const spoofed = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '203.0.113.9, 198.51.100.1' }); + assert.equal(spoofed.res.status, 429); + + // Ohne TRUST_PROXY lässt sich die Sperre nicht mit dem Header umgehen. + for (let i = 0; i < 10; i++) { + await createTransfer(direct.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': `198.51.100.${i}` }); + } + const stillBlocked = await createTransfer(direct.base, [file], {}, { 'X-Forwarded-For': '203.0.113.50' }); + assert.equal(stillBlocked.res.status, 429); +}); + +test('Grenzen und fehlerhafte Anfragen', async (t) => { + const ctx = await startApp({ MAX_TRANSFER_SIZE: '1MB', MAX_FILES: '3' }); + t.after(() => ctx.stop()); + const post = (body, headers = JSON_HEADERS) => + fetch(`${ctx.base}/api/transfers`, { method: 'POST', headers, body }); + const error = async (res) => (await res.json()).error; + + const tooLarge = await post(JSON.stringify({ code: CODE, files: [{ name: 'a', size: 1024 ** 2 + 1 }] })); + assert.equal(tooLarge.status, 413); + assert.deepEqual(await tooLarge.json(), { error: 'too_large', maxBytes: 1024 ** 2 }); + + const sumTooLarge = await post( + JSON.stringify({ code: CODE, files: [{ name: 'a', size: 600_000 }, { name: 'b', size: 600_000 }] }), + ); + assert.equal(sumTooLarge.status, 413); + + const tooMany = await post( + JSON.stringify({ code: CODE, files: Array.from({ length: 4 }, (_, i) => ({ name: `f${i}`, size: 1 })) }), + ); + assert.equal(tooMany.status, 413); + assert.deepEqual(await tooMany.json(), { error: 'too_many_files', maxFiles: 3 }); + + for (const files of [ + undefined, + [], + 'text', + [{ name: 'a' }], + [{ name: 'a', size: -1 }], + [{ name: 'a', size: 1.5 }], + [{ name: 'a', size: '5' }], + [{ name: 5, size: 5 }], + [{ name: 'x'.repeat(2000), size: 5 }], + [null], + ]) { + const res = await post(JSON.stringify({ code: CODE, files })); + assert.equal(res.status, 400, JSON.stringify(files)?.slice(0, 40)); + } + + const badExpiry = await post(JSON.stringify({ code: CODE, expiryDays: 365, files: [{ name: 'a', size: 1 }] })); + assert.equal(badExpiry.status, 400); + + assert.equal(await error(await post('{kein json')), 'invalid_json'); + assert.equal(await error(await post('[1,2]')), 'invalid_request'); + const form = await post('code=x', { 'Content-Type': 'application/x-www-form-urlencoded' }); + assert.equal(form.status, 415); + + const huge = await rawRequest(ctx.port, { + method: 'POST', + path: '/api/transfers', + headers: JSON_HEADERS, + body: Buffer.from('{"code":"'), + declaredLength: 10_000_000, + }); + assert.equal(huge.status, 413); + assert.equal(huge.json.error, 'body_too_large'); + + assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0, 'nichts wurde angelegt'); +}); + +test('Regeln beim stückweisen Hochladen', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('daten.bin', 400_000); + const { body: transfer } = await createTransfer(ctx.base, [file]); + const chunk = transfer.chunkBytes; + assert.equal(chunk, 256 * 1024); + + // Vor dem Abschluss ist nichts öffentlich sichtbar + assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404); + + // Falsches oder fehlendes Token + const foreign = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 10), transfer.deleteToken); + assert.equal(foreign.res.status, 403); + const noToken = await fetch(`${ctx.base}/api/transfers/${transfer.id}/files/0?offset=0`, { + method: 'PUT', + body: file.data.subarray(0, 10), + }); + assert.equal(noToken.status, 403); + + // Falsche Stelle: Der Server nennt den richtigen Stand + const ahead = await putChunk(ctx.base, transfer, 0, 5000, file.data.subarray(5000, 6000)); + assert.equal(ahead.res.status, 409); + assert.deepEqual(ahead.body, { error: 'offset_mismatch', received: 0 }); + + // Zu großes Stück, unbekannte Datei, unsinnige Stelle + const oversized = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk + 1)); + assert.equal(oversized.res.status, 413); + assert.equal((await putChunk(ctx.base, transfer, 1, 0, file.data.subarray(0, 10))).res.status, 404); + assert.equal((await putChunk(ctx.base, transfer, 0, 'abc', file.data.subarray(0, 10))).res.status, 400); + + const first = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk)); + assert.deepEqual(first.body, { received: chunk }); + + // Dasselbe Stück noch einmal: wird abgelehnt, nichts wird doppelt geschrieben + const repeat = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk)); + assert.equal(repeat.res.status, 409); + assert.equal(repeat.body.received, chunk); + + // Mehr als zur Datei gehört + const overflow = await putChunk(ctx.base, transfer, 0, chunk, Buffer.alloc(400_000 - chunk + 1)); + assert.equal(overflow.res.status, 413); + + // Zu früh abschließen + const early = await finish(ctx.base, transfer); + assert.equal(early.res.status, 409); + assert.equal(early.body.error, 'incomplete'); + + const status = await fetch(`${ctx.base}/api/transfers/${transfer.id}/upload`, { + headers: { Authorization: `Bearer ${transfer.uploadToken}` }, + }); + assert.deepEqual(await status.json(), { + state: 'uploading', + expiresAt: null, + files: [{ size: 400_000, received: chunk }], + }); + + const last = await putChunk(ctx.base, transfer, 0, chunk, file.data.subarray(chunk)); + assert.deepEqual(last.body, { received: 400_000 }); + const done = await finish(ctx.base, transfer); + assert.equal(done.res.status, 200); + // Abschließen ist wiederholbar (falls die Antwort verloren ging) + const doneAgain = await finish(ctx.base, transfer); + assert.equal(doneAgain.res.status, 200); + assert.equal(doneAgain.body.expiresAt, done.body.expiresAt); + + // Nach dem Abschluss lässt sich nichts mehr überschreiben + const late = await putChunk(ctx.base, transfer, 0, 400_000, Buffer.alloc(0)); + assert.equal(late.res.status, 409); + assert.equal(late.body.error, 'not_uploading'); + + const download = await fetch(`${ctx.base}/d/${transfer.id}/0`); + assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data); +}); + +test('Fehlermeldung kommt an, auch wenn der Browser noch sendet', async (t) => { + // Große Stücke, damit der Körper nicht einfach in den Netzwerkpuffern verschwindet. + const ctx = await startApp({ CHUNK_SIZE: '8MB' }); + t.after(() => ctx.stop()); + const file = randomFile('daten.bin', 9_000_000); + const { body: transfer } = await createTransfer(ctx.base, [file]); + const headers = { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' }; + + // Stück an falscher Stelle: Die Antwort 409 muss trotz großem Körper lesbar sein. + const wrongPlace = await rawRequest(ctx.port, { + method: 'PUT', + path: `/api/transfers/${transfer.id}/files/0?offset=1000`, + headers, + body: file.data.subarray(1000, 8_001_000), + declaredLength: 8_000_000, + }); + assert.equal(wrongPlace.status, 409); + assert.deepEqual(wrongPlace.json, { error: 'offset_mismatch', received: 0 }); + assert.notEqual(wrongPlace.headers.connection, 'close', 'die Verbindung bleibt nutzbar'); + + // Falsches Token: genauso + const forbidden = await rawRequest(ctx.port, { + method: 'PUT', + path: `/api/transfers/${transfer.id}/files/0?offset=0`, + headers: { ...headers, Authorization: `Bearer ${'x'.repeat(43)}` }, + body: file.data.subarray(0, 8_000_000), + declaredLength: 8_000_000, + }); + assert.equal(forbidden.status, 403); + + // Mehr angekündigt als erlaubt: Der Server wartet den Körper gar nicht erst ab. + const tooBig = await rawRequest(ctx.port, { + method: 'PUT', + path: `/api/transfers/${transfer.id}/files/0?offset=0`, + headers, + body: file.data.subarray(0, 1000), + declaredLength: 500_000_000, + }); + assert.equal(tooBig.status, 413); + assert.equal(tooBig.headers.connection, 'close'); + + // Danach funktioniert der Upload normal weiter. + const ok = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 8 * 1024 ** 2)); + assert.deepEqual(ok.body, { received: 8 * 1024 ** 2 }); +}); + +test('Abgebrochenes Stück lässt sich wiederholen', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('daten.bin', 200_000); + const { body: transfer } = await createTransfer(ctx.base, [file]); + + // Verbindung reißt mitten im Stück ab + const aborted = await rawRequest(ctx.port, { + method: 'PUT', + path: `/api/transfers/${transfer.id}/files/0?offset=0`, + headers: { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' }, + body: file.data.subarray(0, 50_000), + declaredLength: 200_000, + abort: true, + }); + assert.equal(aborted.aborted, true); + + // Der Server zählt das halbe Stück nicht und nimmt es danach vollständig an. + let retry; + for (let i = 0; i < 40; i++) { + retry = await putChunk(ctx.base, transfer, 0, 0, file.data); + if (retry.res.status !== 409 || retry.body.error !== 'busy') break; + await sleep(50); + } + assert.equal(retry.res.status, 200); + assert.deepEqual(retry.body, { received: 200_000 }); + assert.equal((await finish(ctx.base, transfer)).res.status, 200); + const download = await fetch(`${ctx.base}/d/${transfer.id}/0`); + assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data); +}); + +test('Löschen nur mit dem Lösch-Token', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 5000)]); + const dir = path.join(ctx.dataDir, 'transfers', transfer.id); + const del = (token) => + fetch(`${ctx.base}/api/transfers/${transfer.id}`, { + method: 'DELETE', + headers: token ? { Authorization: `Bearer ${token}` } : {}, + }); + + assert.equal((await del()).status, 403); + assert.equal((await del(transfer.uploadToken)).status, 403); + assert.equal((await del('x'.repeat(43))).status, 403); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 200); + + assert.equal((await del(transfer.deleteToken)).status, 204); + assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404); + await assert.rejects(fs.access(dir)); + assert.equal((await del(transfer.deleteToken)).status, 404); +}); + +test('Ein angefangener Upload lässt sich verwerfen', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('a.bin', 5000); + const { body: transfer } = await createTransfer(ctx.base, [file]); + await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 1000)); + const res = await fetch(`${ctx.base}/api/transfers/${transfer.id}`, { + method: 'DELETE', + headers: { Authorization: `Bearer ${transfer.deleteToken}` }, + }); + assert.equal(res.status, 204); + assert.equal((await putChunk(ctx.base, transfer, 0, 1000, file.data.subarray(1000))).res.status, 404); + assert.equal(ctx.app.store.size, 0); +}); + +test('Abgelaufene und liegen gebliebene Transfers werden entfernt', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const ready = await uploadAll(ctx.base, [randomFile('a.bin', 100)]); + const kept = await uploadAll(ctx.base, [randomFile('b.bin', 100)]); + const { body: unfinished } = await createTransfer(ctx.base, [randomFile('c.bin', 100)]); + const dirOf = (id) => path.join(ctx.dataDir, 'transfers', id); + + // Frist abgelaufen: sofort nicht mehr abrufbar, auch vor dem Aufräumen + ctx.app.store.get(ready.id).expiresAt = Date.now() - 1; + assert.equal((await fetch(`${ctx.base}/api/transfers/${ready.id}`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${ready.id}/0`)).status, 404); + assert.equal((await fetch(`${ctx.base}/d/${ready.id}`)).status, 404); + + // Upload, an dem lange nichts mehr passiert ist + ctx.app.store.get(unfinished.id).lastActivity = Date.now() - ctx.config.staleUploadMs - 1; + + assert.equal(await ctx.app.store.sweep(), 2); + await assert.rejects(fs.access(dirOf(ready.id))); + await assert.rejects(fs.access(dirOf(unfinished.id))); + await fs.access(dirOf(kept.id)); + assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 200); + + // Ordner von Hand gelöscht: Der Eintrag verschwindet beim nächsten Aufräumen + await fs.rm(dirOf(kept.id), { recursive: true }); + assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 404); + assert.equal(await ctx.app.store.sweep(), 1); + assert.equal(ctx.app.store.size, 0); +}); + +test('Nach einem Neustart ist alles wieder da', async (t) => { + const first = await startApp(); + const files = [randomFile('fertig.bin', 300_000)]; + const ready = await uploadAll(first.base, files); + const partial = randomFile('halb.bin', 600_000); + const { body: uploading } = await createTransfer(first.base, [partial]); + await putChunk(first.base, uploading, 0, 0, partial.data.subarray(0, 256 * 1024)); + await first.stop({ keepData: true }); + + const second = await startApp({}, { dataDir: first.dataDir }); + t.after(() => second.stop()); + assert.equal(second.app.store.size, 2); + + const download = await fetch(`${second.base}/d/${ready.id}/0`); + assert.deepEqual(Buffer.from(await download.arrayBuffer()), files[0].data); + const info = await (await fetch(`${second.base}/api/transfers/${ready.id}`)).json(); + assert.equal(info.expiresAt, ready.expiresAt); + + // Der angefangene Upload geht an der alten Stelle weiter + const status = await fetch(`${second.base}/api/transfers/${uploading.id}/upload`, { + headers: { Authorization: `Bearer ${uploading.uploadToken}` }, + }); + assert.equal((await status.json()).files[0].received, 256 * 1024); + let offset = 256 * 1024; + while (offset < partial.data.length) { + const result = await putChunk(second.base, uploading, 0, offset, partial.data.subarray(offset, offset + 256 * 1024)); + assert.equal(result.res.status, 200); + offset = result.body.received; + } + assert.equal((await finish(second.base, uploading)).res.status, 200); + const resumed = await fetch(`${second.base}/d/${uploading.id}/0`); + assert.deepEqual(Buffer.from(await resumed.arrayBuffer()), partial.data); +}); + +test('Beschädigte Ordner im Datenverzeichnis stören den Start nicht', async (t) => { + const first = await startApp(); + const ready = await uploadAll(first.base, [randomFile('a.bin', 100)]); + await first.stop({ keepData: true }); + const transfers = path.join(first.dataDir, 'transfers'); + await fs.mkdir(path.join(transfers, 'abcdefgh23')); + await fs.writeFile(path.join(transfers, 'abcdefgh23', 'meta.json'), '{kaputt'); + await fs.mkdir(path.join(transfers, 'bcdefgh234')); + await fs.writeFile( + path.join(transfers, 'bcdefgh234', 'meta.json'), + JSON.stringify({ v: 1, id: 'ein-anderer', state: 'ready', files: [] }), + ); + await fs.mkdir(path.join(transfers, 'kein-transfer')); + await fs.writeFile(path.join(transfers, 'notiz.txt'), 'hallo'); + + const second = await startApp({}, { dataDir: first.dataDir }); + t.after(() => second.stop()); + assert.equal(second.app.store.size, 1); + assert.equal((await fetch(`${second.base}/d/${ready.id}/0`)).status, 200); + assert.equal(second.logs.filter((line) => line.includes('übersprungen')).length, 2); + assert.equal((await fetch(`${second.base}/d/abcdefgh23`)).status, 404); +}); + +test('Kennungen lassen sich nicht in großem Stil durchprobieren', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 100)]); + + for (let i = 0; i < 60; i++) { + const res = await fetch(`${ctx.base}/api/transfers/2222222222`); + assert.equal(res.status, 404); + } + const api = await fetch(`${ctx.base}/api/transfers/2222222222`); + assert.equal(api.status, 429); + assert.ok(Number(api.headers.get('retry-after')) > 0); + // Die Sperre gilt dann auch für Seiten und Dateien … + const page = await fetch(`${ctx.base}/d/${transfer.id}`); + assert.equal(page.status, 429); + await page.text(); + assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 429); + // … aber nicht für die Startseite. + assert.equal((await fetch(`${ctx.base}/`)).status, 200); +}); + +test('Ohne Upload-Codes ist das Hochladen gesperrt', async (t) => { + const ctx = await startApp({ UPLOAD_CODES: '' }); + t.after(() => ctx.stop()); + const config = await (await fetch(`${ctx.base}/api/config`)).json(); + assert.equal(config.uploadsEnabled, false); + const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]); + assert.equal(res.res.status, 503); + assert.equal(res.body.error, 'uploads_disabled'); +}); + +test('Mit OPEN_UPLOADS geht es ohne Code', async (t) => { + const ctx = await startApp({ UPLOAD_CODES: '', OPEN_UPLOADS: '1' }); + t.after(() => ctx.stop()); + const config = await (await fetch(`${ctx.base}/api/config`)).json(); + assert.deepEqual([config.uploadsEnabled, config.codeRequired], [true, false]); + const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)], { code: undefined }); + assert.equal(res.res.status, 201); +}); + +test('Mehrere Codes; jeder wird im Protokoll mit Namen geführt', async (t) => { + const ctx = await startApp({ UPLOAD_CODES: 'anna:annas-geheimnis,ben:bens-geheimnis' }); + t.after(() => ctx.stop()); + const file = randomFile('a.txt', 10); + assert.equal((await createTransfer(ctx.base, [file], { code: 'annas-geheimnis' })).res.status, 201); + assert.equal((await createTransfer(ctx.base, [file], { code: 'bens-geheimnis' })).res.status, 201); + assert.equal((await createTransfer(ctx.base, [file], { code: 'anna' })).res.status, 401); + assert.equal((await createTransfer(ctx.base, [file], { code: 'anna:annas-geheimnis' })).res.status, 401); + assert.ok(ctx.logs.some((line) => line.includes('Code "anna"'))); + assert.ok(ctx.logs.some((line) => line.includes('Code "ben"'))); +}); + +test('Das Speicherkontingent wird eingehalten', async (t) => { + const ctx = await startApp({ STORAGE_QUOTA: '1MB', MIN_FREE_SPACE: '0' }); + t.after(() => ctx.stop()); + const post = (size) => + fetch(`${ctx.base}/api/transfers`, { + method: 'POST', + headers: JSON_HEADERS, + body: JSON.stringify({ code: CODE, files: [{ name: 'a.bin', size }] }), + }); + const first = await post(700_000); + assert.equal(first.status, 201); + const second = await post(400_000); + assert.equal(second.status, 507); + assert.deepEqual(await second.json(), { error: 'storage_full' }); + assert.equal((await post(300_000)).status, 201); + + // Nach dem Löschen ist der Platz wieder frei + const transfer = await first.json(); + await fetch(`${ctx.base}/api/transfers/${transfer.id}`, { + method: 'DELETE', + headers: { Authorization: `Bearer ${transfer.deleteToken}` }, + }); + assert.equal((await post(700_000)).status, 201); +}); + +test('Zu wenig freier Plattenplatz wird vorher bemerkt', async (t) => { + // Verlangt mehr freien Platz, als irgendeine Platte hat. + const ctx = await startApp({ MIN_FREE_SPACE: '900000TB' }); + t.after(() => ctx.stop()); + const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]); + assert.equal(res.res.status, 507); + assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0); +}); + +test('Gleichzeitige Uploads kommen sich nicht in die Quere', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const sets = Array.from({ length: 6 }, (_, i) => [randomFile(`a${i}.bin`, 300_000 + i), randomFile(`b${i}.bin`, 1000 + i)]); + const transfers = await Promise.all(sets.map((files) => uploadAll(ctx.base, files))); + assert.equal(new Set(transfers.map((tr) => tr.id)).size, 6); + await Promise.all( + transfers.map(async (transfer, i) => { + for (let index = 0; index < 2; index++) { + const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`); + assert.deepEqual(Buffer.from(await res.arrayBuffer()), sets[i][index].data); + } + }), + ); +}); + +test('Eine abgerissene Verbindung blockiert die Datei nicht', async (t) => { + const ctx = await startApp(); + t.after(() => ctx.stop()); + const file = randomFile('daten.bin', 1000); + const { body: created } = await createTransfer(ctx.base, [file]); + const transfer = ctx.app.store.get(created.id); + + // Verbindung ist schon weg, bevor das Schreiben beginnt + const gone = new Readable({ read() {} }); + gone.destroy(); + await assert.rejects(ctx.app.store.writeChunk(transfer, 0, 0, gone, 1000)); + + // Verbindung reißt mitten im Schreiben ab + const breaking = new Readable({ read() {} }); + const pending = ctx.app.store.writeChunk(transfer, 0, 0, breaking, 1000); + breaking.push(file.data.subarray(0, 400)); + await sleep(20); + breaking.destroy(); + await assert.rejects(pending); + assert.equal(transfer.files[0].received, 0); + assert.equal(transfer.files[0].busy, false); + + // Danach lässt sich die Datei ganz normal hochladen + const ok = await putChunk(ctx.base, created, 0, 0, file.data); + assert.deepEqual(ok.body, { received: 1000 }); + assert.equal((await finish(ctx.base, created)).res.status, 200); + const download = await fetch(`${ctx.base}/d/${created.id}/0`); + assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data); +}); diff --git a/test/helpers.js b/test/helpers.js new file mode 100644 index 0000000..360fcb7 --- /dev/null +++ b/test/helpers.js @@ -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)); diff --git a/test/units.test.js b/test/units.test.js new file mode 100644 index 0000000..e10f422 --- /dev/null +++ b/test/units.test.js @@ -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); +}); diff --git a/tools/transfers.js b/tools/transfers.js new file mode 100644 index 0000000..1f08ab9 --- /dev/null +++ b/tools/transfers.js @@ -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 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 '); + process.exit(command ? 1 : 0); +}