sgcWebSockets 2026.6: gRPC, OpenAPI-Server, Kafka und natives TLS

· Versionen

sgcWebSockets 2026.6 ist eines der größten Releases in der Geschichte der Bibliothek. Es bringt drei brandneue Clients (einen nativen gRPC-Client, einen Apache Kafka-Client und einen eigenständigen OpenAPI-3-Server), zwei native Betriebssystem-TLS-Backends, mit denen Ihre Mobil- und Desktop-Apps ohne OpenSSL ausgeliefert werden können, eine rein klassifizierende Bot-Erkennung in der Firewall, einen MCP-stdio-Transport für KI-Agenten, eine Reihe von Post-Quantum-Krypto-Primitiven sowie eine umfassende Sicherheitshärtung der WebSocket- und HTTP-Server.

Dieser Beitrag ist eine geführte Tour durch die Highlights, mit einem kurzen Delphi-Snippet zu jedem Thema und einem Link zum eigenen Artikel, in dem jede Funktion ausführlich behandelt wird.

gRPC-Client über HTTP/2

Der neue TsgcGRPCClient ist ein nativer gRPC-Client, der auf dem bestehenden TsgcHTTP2Client aufbaut, ohne externe gRPC-Laufzeitumgebung zur Auslieferung. Er unterstützt die vier RPC-Muster (unary, server streaming, client streaming und bidirectional streaming), Channel-Optionen für Kompression und Content-Type, Standard- und Per-Call-Metadaten, Deadlines, automatische Wiederholungen mit exponentiellem Backoff, clientseitiges Load Balancing (Pick First und Round Robin), gRPC Health Checking, Server Reflection, Interceptors und OpenTelemetry-Metriken.

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;

Zusätzlich zum generischen Client liefert 2026.6 typisierte gRPC-Schnittstellen für acht Google-Cloud-Dienste, jeweils mit Protobuf-Request- und -Response-Klassen sowie Service-Account-JWT-Authentifizierung: Pub/Sub, Speech-to-Text, Translation, Vision, Natural Language, Cloud Storage, BigQuery Storage und Vertex AI. Vollständige Anleitung: gRPC-Client für Delphi.

Eigenständiger OpenAPI-3-Server

TsgcWSAPIServer_OpenAPI verwandelt eine OpenAPI-3-Spezifikation in einen laufenden REST-Server. Laden Sie eine Spezifikation (oder erzeugen Sie eine aus einer Delphi-Klasse über RTTI-Attribute), hängen Sie sie an einen TsgcWebSocketHTTPServer, und Sie erhalten Routing, Request-Validierung, Swagger UI und CORS standardmäßig. Validierungsfehler liefern automatisch RFC-7807-problem+json zurück.

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;

Mehr dazu: OpenAPI-Server für Delphi.

Apache-Kafka-Client

TsgcWSPClient_Kafka ist ein nativer Apache-Kafka-Client, der das binäre Kafka-Wire-Protokoll über rohes TCP spricht, ohne Java- oder librdkafka-Abhängigkeit. Erzeugen und konsumieren Sie Nachrichten, abonnieren und pollen Sie, und verwalten Sie Consumer-Gruppen, Topics und 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;

Mehr dazu: Apache-Kafka-Client für Delphi.

Natives TLS auf Android und Apple, ohne OpenSSL zur Auslieferung

Zwei neue TLS-Backends führen den Handshake über das Betriebssystem statt über OpenSSL aus, sodass Ihre App weder libssl.so / libcrypto.so auf Android noch eine .dylib auf iOS und macOS ausliefert. Beide werden pro Plattform über TLSOptions.IOHandler ausgewählt und nutzen dieselbe TLSOptions-API wieder, die Sie bereits verwenden (eigene CA, Client-Zertifikat, ALPN).

Android (iohAndroidTLS) führt TLS über die Plattform-javax.net.ssl.SSLEngine via JNI aus, validiert gegen den Android-System-Trust-Store mit Hostnamen-Prüfung, verhandelt TLS 1.3 und unterstützt ALPN ab Android 10. Erfordert 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) wählt automatisch Network.framework für TLS 1.3 auf macOS 10.14+ und iOS 12+ und fällt auf älteren Systemen auf Secure Transport (TLS 1.2) zurück. Es nutzt den System-Trust-Store mit SNI und Hostnamen-Prüfung und stellt das Event OnAppleTLSVerifyPeer für eine eigene Validierung bereit. Erfordert RAD Studio XE6+.

uses
  sgcWebSocket, sgcWebSocket_Types;

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

Mehr dazu: Natives Android-TLS und Natives Apple-TLS.

Bot-Erkennung in der Firewall

TsgcWebSocketFirewall erhält ein IP-basiertes Bot-Erkennungsmodul, das einen Client als verifizierten Suchmaschinen-Crawler, als Rechenzentrums-Bereich oder als auf der Sperrliste stehende Adresse klassifiziert, anhand bekannter Bot-CIDR-Listen, Rechenzentrums-ASN-Bereichen, forward-confirmed reverse DNS (FCrDNS) und DNSBL-Abfragen. Es ist rein klassifizierend: Das Ergebnis wird über das neue Event OnBotDetected und die Methode GetBotClassification bereitgestellt, sodass Sie selbst entscheiden, was damit geschehen soll, anstatt dass die Firewall Verbindungen für Sie blockiert.

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

Dieses Release bringt der Firewall außerdem vollständiges IPv6: Blacklist- und Whitelist-CIDR-Abgleich bis /128, GeoLite2-IPv6-Ländersperren, IPv6-Bot-Bereiche und ip6.arpa-Reverse-DNS / DNSBL. Ein langjähriger Fehler, bei dem ein IPv6-CIDR mit 32-Bit-Arithmetik ausgewertet wurde (und somit jeden IPv6-Client traf), ist behoben. Mehr dazu: Bot-Erkennung in der Firewall.

MCP-stdio-Transport

Der Model-Context-Protocol-Server und -Client können nun über die Standardein-/-ausgabe laufen, dank des neuen Hosts TsgcAI_MCP_Server_Stdio, sodass Ihr Delphi-MCP-Server als lokaler Subprozess von KI-Agenten wie Claude Code gestartet werden kann. Tools werden genauso registriert wie auf dem 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.

Mehr dazu: MCP-stdio-Transport für Server und Client.

Standardmäßig gehärtet

2026.6 behebt eine Reihe von Denial-of-Service- und Protokollkonformitätsproblemen in den Servern und macht die neuen Limits als Eigenschaften mit sicheren Standardwerten verfügbar.

Die WebSocket-Server begrenzen jetzt den Nachrichtenspeicher mit MaxMessageSize (Standard 64 MB, 0 = unbegrenzt) und weisen übergroße Nachrichten, endlose Fragmentierung und permessage-deflate-„Zip-Bomben" mit Close 1009 ab. Die neuen Optionen SecurityOptions.EnforceWebSocketVersion und SecurityOptions.ValidateWebSocketKey validieren den RFC-6455-Handshake, beide standardmäßig aktiviert.

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;

Der HTTP-Server ergänzt MaxRequestBodySize (Standard 64 MB) und StrictRequestParsing (Standard True, weist eine Anfrage ab, die sowohl Content-Length als auch Transfer-Encoding mitführt). Path Traversal beim Ausliefern statischer Dateien ist behoben, HTTP/2 Rapid Reset (CVE-2023-44487) wird mit Per-Connection-RST_STREAM- und Control-Frame-Limits abgemildert, und DocumentRoot-Dateien werden nun mit einem gemeinsam genutzten TFileStream direkt von der Festplatte gestreamt, statt vollständig in den Speicher geladen zu werden, sodass der RAM-Verbrauch des Servers unabhängig von Dateigröße oder Verbindungsanzahl konstant bleibt.

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

Mehr dazu: Härtung des WebSocket-Servers und Härtung des HTTP-Servers.

Post-Quantum- und AEAD-Krypto

Für Anwendungen, die hybride Post-Quantum-Handshakes aufbauen, ergänzt 2026.6 ML-KEM-768-Encapsulation und -Decapsulation (sgcKEM_MLKEM768_Encapsulate / Decapsulate, OpenSSL 3.5+) neben einem klassischen ECDH-als-KEM über P-256 (sgcKEM_ECDH_P256_Encapsulate / Decapsulate), das dieselbe TBytes-API-Form teilt, sodass Sie zwischen klassischen und Post-Quantum-KEMs wechseln können, ohne Ihren Code zu ändern.

Eine neue Unit sgcSSL_AEAD stellt generische AEAD-Primitive (sgcAEAD_Encrypt / sgcAEAD_Decrypt) für AES-128-GCM, AES-256-GCM und ChaCha20-Poly1305 bereit, mit einem vom Aufrufer bereitgestellten 12-Byte-Nonce und beliebigen AAD. Die Wrapper sgcAEAD_EncryptPrefixed / sgcAEAD_DecryptPrefixed erzeugen und verarbeiten den eigenständigen „nonce(12) || ciphertext || tag(16)"-Blob, der von Bouncy Castle GCM, JOSE A256GCM, libsodium und den meisten Protokollen im HPKE-Stil verwendet wird.

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

Eine neue REST-API in Ihrem eSeGeCe-Konto ermöglicht es Ihnen, sich anzumelden sowie die Dateien aufzulisten und herunterzuladen, zu denen Ihr Abonnement berechtigt, direkt aus Skripten oder CI. Sie ist mit OpenAPI 3.0 beschrieben und wird mit einem einsatzbereiten Delphi-Client geliefert, der auf sgcOpenAPI aufbaut.

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

Mehr dazu: Automatisieren Sie Ihre Downloads mit der Account-API.

Außerdem in diesem Release

Aktualisierung

2026.6 ist ein nahtloses Upgrade für bestehende 2026.x-Projekte. Die Server-Härtung wird mit sicheren Standardwerten ausgeliefert, sodass das Einzige, worauf zu achten ist, der 64-MB-Standardwert von MaxMessageSize / MaxRequestBodySize ist: Wenn Ihre Anwendung legitim größere Payloads austauscht, erhöhen Sie das Limit (oder setzen Sie es auf 0 für unbegrenzt), um Ihr bisheriges Verhalten beizubehalten.

Kunden mit einem aktiven Abonnement können den neuen Build im Kundenbereich oder unter esegece.com/products/websockets/download herunterladen.

Fragen, Feedback oder Hilfe bei der Migration? Kontaktieren Sie uns. Sie erhalten eine Antwort von den Leuten, die den Code geschrieben haben.