sgcWebSockets 2026.6 : gRPC, serveur OpenAPI, Kafka et TLS natif

· Versions

sgcWebSockets 2026.6 est l'une des plus grandes versions de l'histoire de la bibliothèque. Elle apporte trois clients tout neufs (un client gRPC natif, un client Apache Kafka et un serveur OpenAPI 3 autonome), deux backends TLS natifs du système d'exploitation qui permettent à vos applications mobiles et de bureau d'être livrées sans OpenSSL, un moteur de détection de bots en mode classification seule dans le pare-feu, un transport MCP stdio pour les agents IA, un ensemble de primitives cryptographiques post-quantiques, et un large travail de renforcement de la sécurité sur les serveurs WebSocket et HTTP.

Cet article propose une visite guidée des nouveautés, avec un court extrait Delphi pour chacune et un lien vers l'article dédié où chaque fonctionnalité est couverte en profondeur.

Client gRPC sur HTTP/2

Le nouveau TsgcGRPCClient est un client gRPC natif construit sur le TsgcHTTP2Client existant, sans runtime gRPC externe à déployer. Il prend en charge les quatre modèles de RPC (unaire, streaming serveur, streaming client et streaming bidirectionnel), les options de canal pour la compression et le type de contenu, les métadonnées par défaut et par appel, les délais, les nouvelles tentatives automatiques avec backoff exponentiel, l'équilibrage de charge côté client (Pick First et Round Robin), la vérification d'état (Health Checking) gRPC, la réflexion de serveur (Server Reflection), les intercepteurs et les métriques OpenTelemetry.

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;

Au-dessus du client générique, 2026.6 livre des interfaces gRPC typées pour huit services Google Cloud, chacune avec des classes de requête et de réponse protobuf et une authentification JWT par compte de service : Pub/Sub, Speech-to-Text, Translation, Vision, Natural Language, Cloud Storage, BigQuery Storage et Vertex AI. Présentation complète : Client gRPC pour Delphi.

Serveur OpenAPI 3 autonome

TsgcWSAPIServer_OpenAPI transforme une spécification OpenAPI 3 en un serveur REST opérationnel. Chargez une spécification (ou générez-en une à partir d'une classe Delphi via des attributs RTTI), rattachez-la à un TsgcWebSocketHTTPServer, et vous obtenez le routage, la validation des requêtes, Swagger UI et CORS prêts à l'emploi. Les échecs de validation renvoient automatiquement du problem+json conforme à la RFC 7807.

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;

En savoir plus : Serveur OpenAPI pour Delphi.

Client Apache Kafka

TsgcWSPClient_Kafka est un client Apache Kafka natif qui parle le protocole filaire binaire de Kafka sur TCP brut, sans dépendance Java ni librdkafka. Produisez et consommez des messages, abonnez-vous et faites du polling, et gérez les groupes de consommateurs, les topics et les 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;

En savoir plus : Client Apache Kafka pour Delphi.

TLS natif sur Android et Apple, sans OpenSSL à déployer

Deux nouveaux backends TLS exécutent le handshake via le système d'exploitation au lieu d'OpenSSL, de sorte que votre application ne livre aucun libssl.so / libcrypto.so sur Android ni aucun .dylib sur iOS et macOS. Les deux sont sélectionnés par plateforme via TLSOptions.IOHandler et réutilisent la même API TLSOptions que vous utilisez déjà (CA personnalisée, certificat client, ALPN).

Android (iohAndroidTLS) exécute TLS via le javax.net.ssl.SSLEngine de la plateforme par JNI, valide par rapport au magasin de confiance système d'Android avec vérification du nom d'hôte, négocie TLS 1.3 et prend en charge ALPN sur Android 10 et versions ultérieures. Nécessite 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) sélectionne automatiquement Network.framework pour TLS 1.3 sur macOS 10.14+ et iOS 12+, et revient à Secure Transport (TLS 1.2) sur les systèmes plus anciens. Il utilise le magasin de confiance système avec SNI et vérification du nom d'hôte, et expose l'événement OnAppleTLSVerifyPeer pour une validation personnalisée. Nécessite RAD Studio XE6+.

uses
  sgcWebSocket, sgcWebSocket_Types;

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

En savoir plus : TLS natif Android et TLS natif Apple.

Détection de bots du pare-feu

TsgcWebSocketFirewall gagne un module de détection de bots basé sur l'IP qui classifie un client comme un crawler de moteur de recherche vérifié, une plage de centre de données ou une adresse sur liste de blocage, en utilisant des listes CIDR de bots connus, des plages ASN de centres de données, le DNS inverse confirmé en avant (FCrDNS) et les recherches DNSBL. Il fonctionne en classification seule : le résultat est exposé via le nouvel événement OnBotDetected et la méthode GetBotClassification, de sorte que vous décidez quoi en faire plutôt que le pare-feu ne bloque les connexions à votre place.

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

Cette version apporte également l'IPv6 complet au pare-feu : correspondance CIDR de liste noire et de liste blanche jusqu'à /128, blocages par pays IPv6 GeoLite2, plages de bots IPv6 et DNS inverse / DNSBL ip6.arpa. Un bug de longue date où un CIDR IPv6 était évalué avec des mathématiques 32 bits (et correspondait donc à chaque client IPv6) est corrigé. En savoir plus : Détection de bots dans le pare-feu.

Transport MCP stdio

Le serveur et le client Model Context Protocol peuvent désormais fonctionner via l'entrée/sortie standard grâce au nouvel hôte TsgcAI_MCP_Server_Stdio, de sorte que votre serveur MCP Delphi peut être lancé comme un sous-processus local par des agents IA tels que Claude Code. Les outils sont enregistrés exactement comme sur le serveur HTTP.

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.

En savoir plus : Transport MCP stdio pour le serveur et le client.

Renforcé par défaut

2026.6 corrige un lot de problèmes de déni de service et de conformité au protocole dans les serveurs, et expose les nouvelles limites sous forme de propriétés avec des valeurs par défaut sûres.

Les serveurs WebSocket bornent désormais la mémoire des messages avec MaxMessageSize (par défaut 64 Mo, 0 = illimité), rejetant les messages surdimensionnés, la fragmentation sans fin et les « bombes zip » permessage-deflate avec la fermeture 1009. Les nouvelles options SecurityOptions.EnforceWebSocketVersion et SecurityOptions.ValidateWebSocketKey valident le handshake RFC 6455, toutes deux activées par défaut.

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;

Le serveur HTTP ajoute MaxRequestBodySize (par défaut 64 Mo) et StrictRequestParsing (par défaut True, rejetant une requête qui porte à la fois Content-Length et Transfer-Encoding). La traversée de répertoire dans le service de fichiers statiques est corrigée, le HTTP/2 Rapid Reset (CVE-2023-44487) est atténué avec des limites de RST_STREAM et de trames de contrôle par connexion, et les fichiers DocumentRoot sont désormais diffusés depuis le disque avec un TFileStream partagé au lieu d'être entièrement chargés en mémoire, de sorte que la RAM du serveur reste stable quelle que soit la taille du fichier ou le nombre de connexions.

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

En savoir plus : Renforcer le serveur WebSocket et Renforcer le serveur HTTP.

Cryptographie post-quantique et AEAD

Pour les applications qui construisent des handshakes post-quantiques hybrides, 2026.6 ajoute l'encapsulation et la décapsulation ML-KEM-768 (sgcKEM_MLKEM768_Encapsulate / Decapsulate, OpenSSL 3.5+) aux côtés d'un ECDH-comme-KEM classique sur P-256 (sgcKEM_ECDH_P256_Encapsulate / Decapsulate) qui partage la même forme d'API TBytes, de sorte que vous pouvez basculer entre les KEM classiques et post-quantiques sans changer votre code.

Une nouvelle unité sgcSSL_AEAD fournit des primitives AEAD génériques (sgcAEAD_Encrypt / sgcAEAD_Decrypt) pour AES-128-GCM, AES-256-GCM et ChaCha20-Poly1305, avec un nonce de 12 octets fourni par l'appelant et un AAD arbitraire. Les wrappers sgcAEAD_EncryptPrefixed / sgcAEAD_DecryptPrefixed produisent et consomment le blob autonome « nonce(12) || ciphertext || tag(16) » utilisé par Bouncy Castle GCM, JOSE A256GCM, libsodium et la plupart des protocoles de type HPKE.

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;

API de téléchargement du compte

Une nouvelle API REST sur votre compte eSeGeCe vous permet de vous connecter, de lister et de télécharger les fichiers auxquels votre abonnement vous donne droit, directement depuis des scripts ou un système d'intégration continue. Elle est décrite avec OpenAPI 3.0 et est livrée avec un client Delphi prêt à l'emploi construit sur sgcOpenAPI.

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

En savoir plus : Automatisez vos téléchargements avec l'API du compte.

Également dans cette version

Mise à niveau

2026.6 est une mise à niveau directe pour les projets 2026.x existants. Le renforcement du serveur est livré avec des valeurs par défaut sûres, donc la seule chose à surveiller est la valeur par défaut de 64 Mo pour MaxMessageSize / MaxRequestBodySize : si votre application échange légitimement des charges utiles plus grandes, augmentez la limite (ou réglez-la sur 0 pour illimité) pour correspondre à votre comportement précédent.

Les clients disposant d'un abonnement actif peuvent télécharger la nouvelle version depuis l'espace client, ou depuis esegece.com/products/websockets/download.

Des questions, des retours ou besoin d'aide pour la migration ? Contactez-nous. Vous obtiendrez une réponse des personnes qui ont écrit le code.