E2EE (End-To-End Encryption) voor Delphi

Vanaf versie 2026.1.0 wordt E2EE (End-To-End Encryption) ondersteund (alleen voor eSeGeCe All-Access-abonnees).

End-to-end-encryptie (E2EE) zorgt ervoor dat alleen de communicerende peers de inhoud van uitgewisselde berichten kunnen lezen. Zelfs de server die de berichten doorstuurt, kan ze niet ontsleutelen. Dit artikel legt uit hoe E2EE werkt tussen twee peers met behulp van public-key-cryptografie om berichten veilig uit te wisselen.

E2EE uitgelegd

Kernprincipes van E2EE

In een E2EE-systeem met twee peers:

• Heeft elke peer een privé-sleutel die zijn apparaat nooit verlaat.
• Publiceert elke peer een publieke sleutel die anderen kunnen zien.
• Worden berichten versleuteld op het apparaat van de afzender en alleen ontsleuteld op het apparaat van de ontvanger.
• Fungeert de server alleen als een bericht-relay, niet als een vertrouwde partij.

Overzicht sleutelmateriaal

Elke peer (bijvoorbeeld Alice en Bob) heeft:

• Privé-sleutel
  Een geheime waarde die lokaal wordt opgeslagen. Mag nooit worden gedeeld.
• Publieke sleutel
  Een waarde die is afgeleid van de privé-sleutel. Mag vrijelijk worden gedeeld.

Publieke en privé-sleutels zijn wiskundig met elkaar verbonden, maar het kennen van de publieke sleutel onthult niet de privé-sleutel.

Stap 1: uitwisseling van publieke sleutels

Voordat versleutelde communicatie kan plaatsvinden, moeten Alice en Bob elkaars publieke sleutels kennen.

Typische benaderingen:

• De server slaat publieke sleutels op en levert ze op aanvraag.
• Publieke sleutels worden uitgewisseld tijdens het aanmaken van een account of bij het eerste contact.

Deze uitwisseling brengt de veiligheid niet in gevaar, omdat publieke sleutels niet geheim zijn.

Stap 2: een gedeeld geheim opzetten (ECDH)

Om berichten efficiënt te versleutelen, leiden Alice en Bob eerst een gedeeld geheim af met behulp van Elliptic Curve Diffie–Hellman (ECDH).

Hoe ECDH conceptueel werkt

• Alice berekent een gedeeld geheim met:
  • Haar privé-sleutel
  • Bobs publieke sleutel
• Bob berekent een gedeeld geheim met:
  • Zijn privé-sleutel
  • Alices publieke sleutel

Vanwege de wiskundige eigenschappen van elliptische krommen produceren beide berekeningen dezelfde geheime waarde, ook al stuurt geen van beide partijen dat geheim ooit door.

Op geen enkel moment wordt het gedeelde geheim over het netwerk verstuurd.

Stap 3: een symmetrische encryptiesleutel afleiden

Het ruwe ECDH-gedeelde geheim wordt niet rechtstreeks gebruikt voor encryptie. In plaats daarvan wordt het verwerkt via een Key Derivation Function (KDF), doorgaans een cryptografische hash zoals SHA-256.

Doel van sleutelafleiding:

• Een sleutel produceren met de juiste lengte (bijv. 32 bytes voor AES-256)
• Structurele bias uit de ruwe ECDH-output verwijderen
• Cryptografische robuustheid verbeteren

Het resultaat is een symmetrische encryptiesleutel die alleen bij Alice en Bob bekend is.

Stap 4: het bericht versleutelen

Wanneer Alice een bericht naar Bob wil sturen:

1. Alice converteert het bericht naar bytes.
2. Alice versleutelt het bericht met een symmetrische cipher (meestal AES-GCM) met:
   • De afgeleide symmetrische sleutel
   • Een willekeurige initialisatievector (IV)
3. Alice stuurt het versleutelde bericht en de IV via de server naar Bob.

AES-GCM wordt vaak gebruikt omdat het het volgende biedt:

• Vertrouwelijkheid (encryptie)
• Integriteit (manipulatiedetectie)
• Authenticiteit (detecteert vervalste berichten)

Stap 5: het bericht ontsleutelen

Wanneer Bob het versleutelde bericht ontvangt:

1. Bob leidt onafhankelijk dezelfde symmetrische sleutel af via ECDH en dezelfde KDF.
2. Bob ontsleutelt het bericht met de symmetrische sleutel en de IV.
3. Als de authenticatie slaagt, krijgt Bob de oorspronkelijke leesbare tekst.

Als het bericht is gewijzigd of de verkeerde sleutel wordt gebruikt, mislukt de decryptie.

Rol van de server

In deze architectuur:

• Levert de server publieke sleutels af
• Routeert de server versleutelde berichten
• Beheert de server gebruikersaanwezigheid of metadata

De server kan:

• Geen gedeelde geheimen afleiden
• Geen berichten ontsleutelen
• Geen geldige versleutelde berichten vervalsen

Dit is de bepalende eigenschap van end-to-end-encryptie.

Samenvatting

End-to-end-encryptie tussen twee peers werkt door het combineren van:

1. Public-key-cryptografie (voor sleutelovereenkomst)
2. Symmetrische cryptografie (voor efficiënte berichtversleuteling)
3. Key Derivation Functions (voor veiligheid en correctheid)

Het resultaat is een systeem waarin:

• Alleen peers berichten kunnen lezen
• De server wordt gereduceerd tot een transportrol
• Privacy door ontwerp wordt gewaarborgd, niet door beleid

Dit model is de cryptografische ruggengraat van moderne veilige berichtensystemen. 

E2EE-voorbeeld

// ... Create the Server
WSServer := TsgcWebSocketHTTPServer.Create(nil);
WSServer.Port := 80;
WSPE2EE := TsgcWSPServer_E2EE.Create(nil);
WSPE2EE.Server := WSServer;
WSServer.Active := True;
// ... Create 2 clients
WSClient1 := TsgcWebSocketClient.Create(nil);
WSClient1.Host := '127.0.0.1';
WSClient1.Port := 80;
E2EE1 := TsgcWSPClient_E2EE.Create(nil);
E2EE1.Client := WSClient1;
E2EE1.E2EE_Otpions.UserId := 'client-1';
WSClient1.Active := True;
WSClient2 := TsgcWebSocketClient.Create(nil);
WSClient2.Host := '127.0.0.1';
WSClient2.Port := 80;
E2EE2 := TsgcWSPClient_E2EE.Create(nil);
E2EE2.OnE2EEMessageText := OnE2EEMessageTextEvent;
E2EE2.E2EE_Otpions.UserId := 'client-2';
E2EE2.Client := WSClient2;
WSClient2.Active := True;
// ... client-1 send a message to client-2
E2EE1.SendDirectMessage('client-2', 'Hello Client-2');
// ... read the message in the OnE2EEMessageText event
procedure OnE2EEMessageText(Sender: TObject; const aFrom, aText: string);
begin
  DoLog('#direct_message: ' + aText);
end;