sgcWebSockets 2026.6: gRPC, OpenAPI-server, Kafka en native TLS

· Releases

sgcWebSockets 2026.6 is een van de grootste releases in de geschiedenis van de bibliotheek. Het brengt drie gloednieuwe clients (een native gRPC-client, een Apache Kafka-client en een standalone OpenAPI 3-server), twee native TLS-backends van het besturingssysteem waarmee je mobiele en desktop-apps zonder OpenSSL kunnen worden uitgeleverd, een classificeer-alleen botdetectie-engine in de firewall, een MCP stdio-transport voor AI-agents, een set post-quantum-crypto-primitieven, en een brede beveiligingshardening-ronde over de WebSocket- en HTTP-servers.

Dit bericht is een begeleide rondleiding langs de hoogtepunten, met een kort Delphi-fragment voor elk en een link naar het specifieke artikel waarin elke functie diepgaand wordt behandeld.

gRPC-client over HTTP/2

De nieuwe TsgcGRPCClient is een native gRPC-client gebouwd op de bestaande TsgcHTTP2Client, zonder een externe gRPC-runtime om uit te rollen. Hij ondersteunt de vier RPC-patronen (unary, server streaming, client streaming en bidirectional streaming), kanaalopties voor compressie en content-type, standaard- en per-call-metadata, deadlines, automatische retries met exponentiële backoff, client-side load balancing (Pick First en Round Robin), gRPC Health Checking, Server Reflection, interceptors en OpenTelemetry-metrieken.

uses
  sgcHTTP2, sgcGRPC_Client, sgcGRPC_Classes, sgcGRPC_Types;

var
  HTTP2: TsgcHTTP2Client;
  GRPC: TsgcGRPCClient;
  oResponse: TsgcGRPCResponse;
begin
  HTTP2 := TsgcHTTP2Client.Create(nil);
  HTTP2.Host := 'grpc.example.com';
  HTTP2.Port := 443;
  HTTP2.TLS  := True;

  GRPC := TsgcGRPCClient.Create(nil);
  GRPC.Client := HTTP2;

  // metadata is sent on every call (auth, tracing...)
  GRPC.DefaultMetadata.Add('authorization', 'Bearer eyJ...');

  // unary call: the request is your serialized protobuf message as TBytes
  oResponse := GRPC.Call('helloworld.Greeter', 'SayHello', RequestBytes);
  if oResponse.StatusCode = grpcOK then
    Memo1.Text := oResponse.DataString
  else
    ShowMessage('gRPC error: ' + oResponse.StatusMessage);
end;

Bovenop de generieke client levert 2026.6 getypeerde gRPC-interfaces voor acht Google Cloud-services, elk met protobuf request- en response-klassen en service-account-JWT-authenticatie: Pub/Sub, Speech-to-Text, Translation, Vision, Natural Language, Cloud Storage, BigQuery Storage en Vertex AI. Volledige uitleg: gRPC Client for Delphi.

Standalone OpenAPI 3-server

TsgcWSAPIServer_OpenAPI maakt van een OpenAPI 3-specificatie een draaiende REST-server. Laad een spec (of genereer er een uit een Delphi-klasse via RTTI-attributen), koppel deze aan een TsgcWebSocketHTTPServer, en je krijgt routing, request-validatie, Swagger UI en CORS standaard. Validatiefouten geven automatisch RFC 7807 problem+json terug.

uses
  sgcWebSocket, sgcWebSocket_Classes,
  sgcWebSocket_Server_API_OpenAPI,
  sgcHTTP_OpenAPI_Server;

var
  WSServer: TsgcWebSocketHTTPServer;
  FOpenAPI: TsgcWSAPIServer_OpenAPI;
begin
  WSServer := TsgcWebSocketHTTPServer.Create(nil);
  WSServer.Port := 8080;

  FOpenAPI := TsgcWSAPIServer_OpenAPI.Create(nil);
  FOpenAPI.OnRequest := OnOpenAPIRequest;
  FOpenAPI.OnValidationError := OnOpenAPIValidationError;

  FOpenAPI.OpenAPIOptions.Endpoint.ServeSpec := True;
  FOpenAPI.OpenAPIOptions.Endpoint.ServeSwaggerUI := True;
  FOpenAPI.OpenAPIOptions.CORS.Enabled := True;
  FOpenAPI.OpenAPIOptions.Validation.ValidateRequest := True;

  FOpenAPI.LoadFromFile('petstore.json');
  FOpenAPI.Server := WSServer;

  WSServer.Active := True;
  // Swagger UI:   http://localhost:8080/docs
  // Raw spec:     http://localhost:8080/openapi.json
end;

Lees meer: OpenAPI Server for Delphi.

Apache Kafka-client

TsgcWSPClient_Kafka is een native Apache Kafka-client die het binaire Kafka-wireprotocol over raw TCP spreekt, zonder Java- of librdkafka-afhankelijkheid. Produceer en consumeer berichten, abonneer en poll, en beheer consumer groups, topics en offsets.

uses
  sgcWebSocket, sgcWebSocket_Protocols, sgcKafka_Classes;

var
  oClient: TsgcWebSocketClient;
  oKafka: TsgcWSPClient_Kafka;
begin
  oClient := TsgcWebSocketClient.Create(nil);
  oClient.Specifications.RFC6455 := False; // raw TCP, native Kafka protocol
  oClient.Host := '127.0.0.1';
  oClient.Port := 9092;

  oKafka := TsgcWSPClient_Kafka.Create(nil);
  oKafka.Client := oClient;
  oKafka.KafkaOptions.ClientId := 'my-delphi-app';
  oKafka.OnKafkaConnect := OnKafkaConnect;
  oKafka.OnKafkaMessage := OnKafkaMessage;
  oKafka.OnKafkaProduce := OnKafkaProduce;

  oClient.Active := True; // connect to the broker
end;

Lees meer: Apache Kafka Client for Delphi.

Native TLS op Android en Apple, geen OpenSSL om uit te rollen

Twee nieuwe TLS-backends voeren de handshake uit via het besturingssysteem in plaats van OpenSSL, zodat je app geen libssl.so / libcrypto.so op Android en geen .dylib op iOS en macOS meeleverd. Beide worden per platform geselecteerd via TLSOptions.IOHandler en hergebruiken dezelfde TLSOptions-API die je al gebruikt (aangepaste CA, clientcertificaat, ALPN).

Android (iohAndroidTLS) voert TLS uit via de platform javax.net.ssl.SSLEngine via JNI, valideert tegen de Android system trust store met hostnameverificatie, onderhandelt TLS 1.3 en ondersteunt ALPN op Android 10 en later. Vereist RAD Studio XE8+.

uses
  sgcWebSocket, sgcWebSocket_Types;

WSClient.TLS := True;
WSClient.TLSOptions.IOHandler := iohAndroidTLS;
WSClient.URL := 'wss://www.esegece.com:2053';
WSClient.Active := True;

Apple (iohAppleTLS) selecteert automatisch Network.framework voor TLS 1.3 op macOS 10.14+ en iOS 12+, en valt terug op Secure Transport (TLS 1.2) op oudere systemen. Het gebruikt de system trust store met SNI- en hostnameverificatie, en stelt het OnAppleTLSVerifyPeer-event beschikbaar voor aangepaste validatie. Vereist RAD Studio XE6+.

uses
  sgcWebSocket, sgcWebSocket_Types;

WSClient.TLS := True;
WSClient.TLSOptions.IOHandler := iohAppleTLS;
WSClient.URL := 'wss://www.esegece.com:2053';
WSClient.Active := True;

Lees meer: Native Android TLS en Native Apple TLS.

Firewall-botdetectie

TsgcWebSocketFirewall krijgt een IP-gebaseerde botdetectiemodule die een client classificeert als een geverifieerde zoekmachine-crawler, een datacenter-range of een geblokkeerd adres, met behulp van bekende-bot-CIDR-lijsten, datacenter-ASN-ranges, forward-confirmed reverse DNS (FCrDNS) en DNSBL-lookups. Het is classificeer-alleen: het resultaat wordt blootgesteld via het nieuwe OnBotDetected-event en de GetBotClassification-methode, zodat jij bepaalt wat ermee gebeurt in plaats van dat de firewall verbindingen voor je blokkeert.

TsgcBotClassification = (bcUnknown, bcVerifiedCrawler, bcDatacenter,
  bcSuspectedBot, bcBlocklisted, bcHuman);

Deze release brengt ook volledige IPv6 naar de firewall: blacklist- en whitelist-CIDR-matching tot /128, GeoLite2 IPv6-landblokken, IPv6-botranges en ip6.arpa reverse DNS / DNSBL. Een al lang bestaande bug waarbij een IPv6-CIDR met 32-bits rekenwerk werd geëvalueerd (en daardoor elke IPv6-client matchte) is opgelost. Lees meer: Bot Detection in the Firewall.

MCP stdio-transport

De Model Context Protocol-server en -client kunnen nu over standaard input/output draaien via de nieuwe TsgcAI_MCP_Server_Stdio-host, zodat je Delphi-MCP-server als een lokaal subproces kan worden gestart door AI-agents zoals Claude Code. Tools worden precies zo geregistreerd als op de HTTP-server.

uses
  SysUtils, sgcAI_MCP_Server, sgcAI_MCP_Classes, sgcAI_MCP_Types;

var
  oServer: TsgcAI_MCP_Server_Stdio;
  oTool: TsgcAI_MCP_Tool;
begin
  oServer := TsgcAI_MCP_Server_Stdio.Create(nil);
  try
    oServer.ServerInfo.Name := 'MyDelphiServer';
    oServer.ServerInfo.Version := '1.0';

    oTool := oServer.MCPServer.Tools.AddTool('add', 'Adds two numbers');
    oTool.InputSchema.Properties.AddProperty('a', True, aimcpjtNumber);
    oTool.InputSchema.Properties.AddProperty('b', True, aimcpjtNumber);

    oServer.MCPServer.OnMCPRequestTool := OnRequestTool;

    // read JSON-RPC from stdin, write responses to stdout, blocks until EOF
    oServer.Run;
  finally
    oServer.Free;
  end;
end.

Lees meer: MCP stdio Transport for Server and Client.

Standaard geharde beveiliging

2026.6 sluit een reeks denial-of-service- en protocolconformiteitsproblemen in de servers, en stelt de nieuwe limieten beschikbaar als eigenschappen met veilige standaardwaarden.

De WebSocket-servers begrenzen nu het berichtengeheugen met MaxMessageSize (standaard 64 MB, 0 = onbeperkt), waarbij te grote berichten, eindeloze fragmentatie en permessage-deflate "zip bombs" worden afgewezen met close 1009. Nieuwe SecurityOptions.EnforceWebSocketVersion en SecurityOptions.ValidateWebSocketKey valideren de RFC 6455-handshake, beide standaard ingeschakeld.

oServer := TsgcWebSocketServer.Create(nil);
oServer.Port := 80;
// accept messages up to 16 MB, reject anything larger with close 1009
oServer.MaxMessageSize := 16 * 1024 * 1024;
oServer.Active := True;

De HTTP-server voegt MaxRequestBodySize (standaard 64 MB) en StrictRequestParsing (standaard True, waarbij een request dat zowel Content-Length als Transfer-Encoding bevat wordt afgewezen) toe. Path traversal bij het serveren van statische bestanden is opgelost, HTTP/2 Rapid Reset (CVE-2023-44487) wordt gemitigeerd met per-connection RST_STREAM- en control-frame-limieten, en DocumentRoot-bestanden worden nu vanaf schijf gestreamd met een gedeelde TFileStream in plaats van volledig in het geheugen te worden geladen, zodat het server-RAM vlak blijft ongeacht bestandsgrootte of aantal verbindingen.

oServer := TsgcWebSocketHTTPServer.Create(nil);
oServer.Port := 80;
oServer.MaxRequestBodySize := 16 * 1024 * 1024;  // 16 MB, reject larger with 413
oServer.Active := True;

Lees meer: Hardening the WebSocket Server en Hardening the HTTP Server.

Post-quantum- en AEAD-crypto

Voor toepassingen die hybride post-quantum-handshakes bouwen, voegt 2026.6 ML-KEM-768-encapsulatie en -decapsulatie toe (sgcKEM_MLKEM768_Encapsulate / Decapsulate, OpenSSL 3.5+) naast een klassieke ECDH-als-KEM over P-256 (sgcKEM_ECDH_P256_Encapsulate / Decapsulate) die dezelfde TBytes-API-vorm deelt, zodat je kunt schakelen tussen klassieke en post-quantum-KEM's zonder je code te wijzigen.

Een nieuwe sgcSSL_AEAD-unit biedt generieke AEAD-primitieven (sgcAEAD_Encrypt / sgcAEAD_Decrypt) voor AES-128-GCM, AES-256-GCM en ChaCha20-Poly1305, met een door de aanroeper geleverde 12-byte nonce en willekeurige AAD. De sgcAEAD_EncryptPrefixed / sgcAEAD_DecryptPrefixed-wrappers produceren en consumeren de self-contained "nonce(12) || ciphertext || tag(16)"-blob die wordt gebruikt door Bouncy Castle GCM, JOSE A256GCM, libsodium en de meeste HPKE-achtige protocollen.

uses
  sgcSSL_AEAD;

var
  vKey, vPlain, vBlob, vOut: TBytes;
begin
  // vKey: 32 bytes from KEM Decapsulate + HKDF
  vBlob := sgcAEAD_EncryptPrefixed(aeadAES256GCM, vKey, vPlain, nil);
  vOut  := sgcAEAD_DecryptPrefixed(aeadAES256GCM, vKey, vBlob, nil);
end;

Account download-API

Een nieuwe REST-API op je eSeGeCe-account laat je inloggen, en de bestanden waarop je abonnement recht geeft opsommen en downloaden, rechtstreeks vanuit scripts of CI. Het wordt beschreven met OpenAPI 3.0 en wordt geleverd met een kant-en-klare Delphi-client gebouwd op sgcOpenAPI.

curl -X POST https://www.esegece.com/api/v1/login \
  -H "Content-Type: application/json" \
  -d '{"username":"YOUR_USERNAME","password":"YOUR_PASSWORD"}'

Lees meer: Automate Your Downloads with the Account API.

Ook in deze release

Upgraden

2026.6 is een drop-in-upgrade voor bestaande 2026.x-projecten. De server-hardening wordt geleverd met veilige standaardwaarden, dus het enige om op te letten is de standaard 64 MB MaxMessageSize / MaxRequestBodySize: als je applicatie legitiem grotere payloads uitwisselt, verhoog dan de limiet (of stel deze in op 0 voor onbeperkt) om je eerdere gedrag te evenaren.

Klanten met een actief abonnement kunnen de nieuwe build downloaden vanuit het klantengedeelte, of vanaf esegece.com/products/websockets/download.

Vragen, feedback of hulp bij migratie? Neem contact op. Je krijgt antwoord van de mensen die de code hebben geschreven.