sgcWebSockets 2026.6: gRPC, server OpenAPI, Kafka e TLS nativo

· Versioni

sgcWebSockets 2026.6 è una delle versioni più grandi nella storia della libreria. Porta tre client completamente nuovi (un client gRPC nativo, un client Apache Kafka e un server OpenAPI 3 autonomo), due backend TLS nativi del sistema operativo che permettono alle tue app mobile e desktop di essere distribuite senza OpenSSL, un motore di rilevamento dei bot di sola classificazione nel firewall, un trasporto stdio per MCP per gli agenti AI, un insieme di primitive crittografiche post-quantum e un ampio intervento di rafforzamento della sicurezza sui server WebSocket e HTTP.

Questo articolo è una panoramica guidata delle novità principali, con un breve frammento Delphi per ciascuna e un collegamento all'articolo dedicato in cui ogni funzionalità è trattata in modo approfondito.

Client gRPC su HTTP/2

Il nuovo TsgcGRPCClient è un client gRPC nativo costruito sull'esistente TsgcHTTP2Client, senza alcun runtime gRPC esterno da distribuire. Supporta i quattro pattern RPC (unario, streaming dal server, streaming dal client e streaming bidirezionale), opzioni di canale per compressione e content-type, metadati predefiniti e per singola chiamata, deadline, tentativi automatici con backoff esponenziale, bilanciamento del carico lato client (Pick First e Round Robin), gRPC Health Checking, Server Reflection, interceptor e metriche 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;

Oltre al client generico, 2026.6 fornisce interfacce gRPC tipizzate per otto servizi Google Cloud, ciascuna con classi di richiesta e risposta protobuf e autenticazione JWT con account di servizio: Pub/Sub, Speech-to-Text, Translation, Vision, Natural Language, Cloud Storage, BigQuery Storage e Vertex AI. Guida completa: Client gRPC per Delphi.

Server OpenAPI 3 autonomo

TsgcWSAPIServer_OpenAPI trasforma una specifica OpenAPI 3 in un server REST funzionante. Carica una specifica (o generane una da una classe Delphi tramite attributi RTTI), collegala a un TsgcWebSocketHTTPServer e ottieni routing, validazione delle richieste, Swagger UI e CORS pronti all'uso. Gli errori di validazione restituiscono automaticamente problem+json conforme a 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;

Leggi di più: Server OpenAPI per Delphi.

Client Apache Kafka

TsgcWSPClient_Kafka è un client Apache Kafka nativo che dialoga con il protocollo binario di Kafka su TCP grezzo, senza dipendenze da Java o librdkafka. Produci e consuma messaggi, sottoscrivi ed esegui il polling, e gestisci gruppi di consumatori, topic e offset.

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;

Leggi di più: Client Apache Kafka per Delphi.

TLS nativo su Android e Apple, senza OpenSSL da distribuire

Due nuovi backend TLS eseguono l'handshake attraverso il sistema operativo invece di OpenSSL, così la tua app non distribuisce alcun libssl.so / libcrypto.so su Android né alcun .dylib su iOS e macOS. Entrambi vengono selezionati per piattaforma tramite TLSOptions.IOHandler e riutilizzano la stessa API TLSOptions che già usi (CA personalizzata, certificato client, ALPN).

Android (iohAndroidTLS) esegue il TLS tramite il javax.net.ssl.SSLEngine della piattaforma via JNI, valida rispetto allo store di trust di sistema di Android con verifica del nome host, negozia TLS 1.3 e supporta ALPN su Android 10 e versioni successive. Richiede 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) seleziona automaticamente Network.framework per TLS 1.3 su macOS 10.14+ e iOS 12+, e ripiega su Secure Transport (TLS 1.2) sui sistemi più vecchi. Usa lo store di trust di sistema con SNI e verifica del nome host, ed espone l'evento OnAppleTLSVerifyPeer per la validazione personalizzata. Richiede RAD Studio XE6+.

uses
  sgcWebSocket, sgcWebSocket_Types;

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

Leggi di più: TLS nativo per Android e TLS nativo per Apple.

Rilevamento dei bot nel firewall

TsgcWebSocketFirewall guadagna un modulo di rilevamento dei bot basato su IP che classifica un client come crawler di motore di ricerca verificato, intervallo di datacenter o indirizzo in blocklist, usando liste CIDR di bot noti, intervalli ASN di datacenter, reverse DNS forward-confirmed (FCrDNS) e lookup DNSBL. È di sola classificazione: il risultato è esposto tramite il nuovo evento OnBotDetected e il metodo GetBotClassification, così sei tu a decidere cosa farne invece che il firewall blocchi le connessioni al posto tuo.

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

Questa versione porta anche l'IPv6 completo al firewall: corrispondenza CIDR di blacklist e whitelist fino a /128, blocchi per paese GeoLite2 IPv6, intervalli di bot IPv6 e reverse DNS / DNSBL ip6.arpa. È stato corretto un bug di lunga data per cui un CIDR IPv6 veniva valutato con aritmetica a 32 bit (e quindi corrispondeva a ogni client IPv6). Leggi di più: Rilevamento dei bot nel firewall.

Trasporto stdio per MCP

Il server e il client del Model Context Protocol possono ora funzionare tramite lo standard input/output grazie al nuovo host TsgcAI_MCP_Server_Stdio, così il tuo server MCP Delphi può essere avviato come sottoprocesso locale da agenti AI come Claude Code. Gli strumenti vengono registrati esattamente come sul server 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.

Leggi di più: Trasporto stdio per MCP per server e client.

Rafforzato per impostazione predefinita

2026.6 chiude una serie di problemi di denial-of-service e di conformità al protocollo nei server, ed espone i nuovi limiti come proprietà con valori predefiniti sicuri.

I server WebSocket ora limitano la memoria dei messaggi con MaxMessageSize (predefinito 64 MB, 0 = illimitato), rifiutando messaggi di dimensioni eccessive, frammentazioni infinite e "zip bomb" di permessage-deflate con close 1009. Le nuove SecurityOptions.EnforceWebSocketVersion e SecurityOptions.ValidateWebSocketKey validano l'handshake RFC 6455, entrambe abilitate per impostazione predefinita.

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;

Il server HTTP aggiunge MaxRequestBodySize (predefinito 64 MB) e StrictRequestParsing (predefinito True, che rifiuta una richiesta contenente sia Content-Length sia Transfer-Encoding). È stato corretto il path traversal nel servizio di file statici, l'HTTP/2 Rapid Reset (CVE-2023-44487) è mitigato con limiti per connessione su RST_STREAM e frame di controllo, e i file di DocumentRoot vengono ora trasmessi dal disco con un TFileStream condiviso invece di essere caricati interamente in memoria, così la RAM del server resta costante indipendentemente dalla dimensione del file o dal numero di connessioni.

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

Leggi di più: Rafforzare il server WebSocket e Rafforzare il server HTTP.

Crittografia post-quantum e AEAD

Per le applicazioni che costruiscono handshake ibridi post-quantum, 2026.6 aggiunge incapsulamento e decapsulamento ML-KEM-768 (sgcKEM_MLKEM768_Encapsulate / Decapsulate, OpenSSL 3.5+) accanto a un classico ECDH-come-KEM su P-256 (sgcKEM_ECDH_P256_Encapsulate / Decapsulate) che condivide la stessa forma di API TBytes, così puoi passare tra KEM classici e post-quantum senza modificare il tuo codice.

Una nuova unit sgcSSL_AEAD fornisce primitive AEAD generiche (sgcAEAD_Encrypt / sgcAEAD_Decrypt) per AES-128-GCM, AES-256-GCM e ChaCha20-Poly1305, con un nonce di 12 byte fornito dal chiamante e AAD arbitrario. I wrapper sgcAEAD_EncryptPrefixed / sgcAEAD_DecryptPrefixed producono e consumano il blob autocontenuto "nonce(12) || ciphertext || tag(16)" usato da Bouncy Castle GCM, JOSE A256GCM, libsodium e dalla maggior parte dei protocolli in stile 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 di download dell'account

Una nuova API REST sul tuo account eSeGeCe ti consente di accedere, elencare e scaricare i file a cui il tuo abbonamento ti dà diritto, direttamente da script o CI. È descritta con OpenAPI 3.0 ed è fornita con un client Delphi pronto all'uso costruito su sgcOpenAPI.

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

Leggi di più: Automatizza i tuoi download con l'API dell'account.

Anche in questa versione

Aggiornamento

2026.6 è un aggiornamento drop-in per i progetti 2026.x esistenti. Il rafforzamento del server è fornito con valori predefiniti sicuri, quindi l'unica cosa a cui prestare attenzione è il valore predefinito di 64 MB di MaxMessageSize / MaxRequestBodySize: se la tua applicazione scambia legittimamente payload più grandi, alza il limite (oppure impostalo a 0 per illimitato) per allinearlo al comportamento precedente.

I clienti con un abbonamento attivo possono scaricare la nuova build dall'area clienti, oppure da esegece.com/products/websockets/download.

Domande, feedback o aiuto con la migrazione? Contattaci. Riceverai una risposta dalle persone che hanno scritto il codice.