Deaddrop, berichten die alleen de ontvanger kan lezen
Deaddrop is een berichtensysteem voor kleine groepen dat je op je eigen server zet. Een bericht wordt in de browser van de afzender versleuteld en pas in de browser van de ontvanger weer leesbaar; de server bewaart ciphertext en weet niet wie het stuurde. Na één keer lezen is het weg. Gewone PHP en JavaScript, zonder framework of buildstap, en gratis op GitHub.
Waarom we Deaddrop bouwden
De meeste veilige chatapps vragen je een aanbieder te vertrouwen: die beheert de servers, de accounts en alles wat daaruit af te lezen is. Voor een redactie, een advocatenkantoor of een team dat gevoelige informatie deelt, is zelf hosten de volgende stap. In de praktijk betekent dat vaak een stapel containers, wachtrijen en afhankelijkheden die je nooit helemaal doorgrondt.
Wij wilden het omgekeerde: iets dat één persoon op een eigen server zet en van begin tot eind kan lezen. Het is gewone PHP zonder externe pakketten, dus de code op GitHub is precies de code die draait.
Deaddrop is ons eigen onderzoeks- en ontwikkelproject. We laten ermee zien hoe we beveiliging in een webapplicatie aanpakken, en we geven het weg zodat je dat zelf kunt nagaan.
Wat erin zit
Leden komen samen in channels. Iedereen heeft eigen sleutels, en elk bericht is voor precies één ontvanger.
Versleuteld voordat het vertrekt
Je kiest een ontvanger, en je browser haalt diens public key op en toont de fingerprint. Heb je die fingerprint eerder met de ander vergeleken, dan staat dat erbij. Je typt het bericht, vult je private pass in om te ondertekenen, en je browser versleutelt. De server krijgt een blok ciphertext en verder niets.
Lezen is wissen
Bij de eerste keer openen stuurt de server de ciphertext precies één keer naar de browser. Na ontsleutelen, na vijf minuten of na vijf verkeerde private passes wist de server hem. Ververs je de pagina, dan staat er niets meer; het bericht bestaat niet meer. Verlopen berichten verdwijnen op dezelfde manier, en na 24 uur is ook de rij in de database weg.
Weten van wie het komt, of juist niet
Een bericht is standaard ondertekend. De ontvanger ziet wie het stuurde en dat de handtekening klopt. Wie anoniem wil blijven, vinkt "anoniem versturen" aan: het bericht heeft dan geen handtekening, en de ontvanger ziet dat het niet te controleren is.
Sleutels die je zelf beheert
Op de pagina Sleutels zie je je eigen fingerprint, wijzig je je private pass zonder dat je contacten iets merken, download je een back-up van je ingepakte sleutels of maak je een nieuw sleutelpaar. Een vergeten private pass is niet via de server te herstellen. Dat is zo ontworpen: wie de server beheert, hoort geen achterdeur naar je berichten te hebben.
Een terminal naast de interface
Alles uit de interface kan ook vanuit een terminal: channels kiezen, leden toevoegen, een ondertekend bericht opstellen, een fingerprint controleren. Hij gebruikt dezelfde serveracties en dezelfde versleuteling als de gewone pagina's.
Beheer zonder achterdeur
Beheerders maken channels en gebruikers aan. Optioneel kan inloggen alleen vanaf apparaten die een beheerder met een eenmalige code heeft geactiveerd; de server bewaart alleen een hash van het apparaatgeheim. Een alleen-lezen Node Admin laat zien of configuratie, migraties en HTTPS in orde zijn, zonder geheimen te tonen.
Hoe de privacy gebouwd is
Hier zit het meeste denkwerk. Bij elke keuze hoort de vraag: wat kan wie de server beheert zien, en wat kan hij ermee?
Twee sleutelparen per gebruiker
Iedereen heeft een RSA-OAEP-sleutelpaar van 4096 bits om berichten te ontvangen en een ECDSA-P-256-sleutelpaar om te ondertekenen. Elk bericht krijgt een eigen AES-256-GCM-sleutel, versleuteld voor de ontvanger. Alles loopt via de Web Crypto API die in elke moderne browser zit, dus geen eigen cryptobibliotheek en niets dat van buiten wordt geladen.
De afzender zit in de envelop
Handtekening, afzender en ontvanger zitten samen in een envelop, en die envelop wordt als geheel versleuteld. De server ziet dus niet wie een bericht stuurde, terwijl de ontvanger het wel kan controleren. Omdat de ontvanger in de handtekening zit, kun je een bericht niet doorsturen alsof het voor een ander bedoeld was. De database heeft helemaal geen afzenderkolom: er stond een ongebruikte, en die hebben we verwijderd, zodat niemand hem later "even" kan vullen.
Een server die sleutels uitdeelt, kan ze ook ruilen
Dit is het zwakke punt van elk systeem met een sleutelregister: vervangt de server de public key van een ontvanger door een eigen sleutel, dan leest hij mee. Deaddrop onthoudt daarom per contact welke fingerprint je eerder zag, in de database én lokaal in je browser. Verandert een sleutel, dan blokkeert je browser het versturen tot je de nieuwe fingerprint buiten Deaddrop hebt gecontroleerd. Een beheerder die de tabel leegmaakt, komt niet langs de lokale kopie.
Je private pass verlaat je browser niet
De private keys staan op de server, ingepakt met een sleutel die uit je private pass wordt afgeleid: PBKDF2 met 600.000 iteraties, de huidige richtlijn van OWASP. Het aantal iteraties staat per gebruiker opgeslagen, zodat het later omhoog kan zonder iemand buiten te sluiten. Oudere sleutels worden automatisch naar de nieuwe standaard gebracht zodra je je pass weer invult.
Burn after read op de server
Een bericht heeft een vaste levensloop: ongeopend, in lezing, en dan geopend, vernietigd, vergrendeld of verlopen. De stap naar "in lezing" is één databasebewerking die maar één keer kan slagen, dus zelfs twee gelijktijdige verzoeken krijgen niet allebei de ciphertext. Een cronjob ruimt elke vijf minuten op wat verlopen is.
Zo min mogelijk metadata
Niet alleen de inhoud verraadt iets. Verzendtijden worden afgerond op vijf minuten, de laatste login en de laatste activiteit van een apparaat op de dag. De bescherming tegen wachtwoorden raden bewaart een sleutelhash (HMAC) van IP-adressen en gebruikersnamen, nooit de waarden zelf, en die rijen verdwijnen na een uur. In de installatiehandleiding is het uitzetten van de toegangslog van de webserver een vaste stap.
Zo min mogelijk afhankelijkheden
Bij een applicatie die je moet kunnen vertrouwen, is elke afhankelijkheid code die je ook moet vertrouwen. Deaddrop is gewone PHP en gewone JavaScript. De Content-Security-Policy staat alleen scripts en stijlen van de server zelf toe, zonder inline code, dus geïnjecteerde HTML kan niets uitvoeren. Elk script wordt geladen met Subresource Integrity.
Controleerbare levering
Eén grens haalt geen enkele webapplicatie weg: de server levert de JavaScript die je private pass verwerkt. Dat verstoppen we niet, we maken het controleerbaar. Elke release heeft een manifest met hashes van alle bestanden, en elke node heeft een openbare pagina die laat zien welke bestanden hij echt uitlevert. In de devtools van je browser meet je de hash van de geladen code zelf na.
De serverstack
Deaddrop vraagt weinig van een server:
- PHP 8.1 of hoger met de extensie pdo_mysql
- MariaDB 10.4+ of MySQL 8.0+
- Een webserver (Nginx, Apache, Caddy of LiteSpeed) met de map
publicals document root - HTTPS: verplicht, want browsers staan de Web Crypto API alleen toe op een beveiligde verbinding
- Een cronjob per vijf minuten voor het opruimen
Installeren is de code ophalen, een configuratiebestand invullen en drie commando's draaien: een sleutel maken, de tabellen aanmaken, de eerste beheerder aanmaken. Ontbreekt er iets in de configuratie of staat er nog een voorbeeldwaarde, dan start de node niet en zegt hij wat er mis is, in plaats van half beveiligd te draaien.
Deployen
Welke server je kiest, hangt af van wie je wilt vertrouwen. De documentatie beschrijft drie niveaus:
- Eenvoudig: één kleine VPS met Debian, een webserver en de database op dezelfde machine. Weinig onderhoud; de VPS-aanbieder heeft fysiek toegang tot de schijf.
- In eigen huis: eigen hardware achter een tunnel, zonder poorten open te zetten op je router, met webserver en database in aparte containers.
- Gehard: eigen hardware met volledige schijfversleuteling, een eigen netwerksegment en geen logging, eventueel als Tor onion service.
Voor elk niveau gelden dezelfde basisregels: de database luistert alleen intern, toegangslogs staan uit, back-ups zijn kortlevend. Gedeelde hosting werkt technisch, maar daar kan de hoster bij alles; dat is alleen geschikt voor een demo met nepdata. Bijwerken is de nieuwe release ophalen, de migraties draaien en de verificatiepagina controleren.
Hoe we testen
Deaddrop begon met een health check van de hele codebase. Daaruit bleek onder meer dat "eenmalig lezen" alleen op het scherm bestond: de server bewaarde een bericht tot iemand op vernietigen klikte. Nu dwingt de server het af, en een test bewijst het.
Die test loopt de hele keten door in een echte Chrome: sleutels maken, een ondertekend bericht versturen, een verkeerde en een goede private pass, verversen tijdens het leesvenster, vijf foute pogingen, een anoniem bericht, de bescherming tegen wachtwoorden raden, oude sleutels upgraden, de pass wijzigen en het opruimen. In een van de 38 controles speelt de test een kwaadwillende server die een sleutel in de database verwisselt, en controleert hij dat de afzender wordt geblokkeerd, ook nadat de server zijn eigen lijst met bekende sleutels heeft leeggemaakt.
Wat je hieraan hebt
Deaddrop is ons eigen product, maar de aanpak is dezelfde in elke applicatie waarin gegevens beschermd moeten blijven: eerst vastleggen wie wat mag zien, dan de server het laten bewijzen, en eerlijk opschrijven waar de bescherming ophoudt. Of het nu een klantportaal met gevoelige documenten is of een interne tool, met die vragen beginnen we.