sgcWebSockets 2026.6: gRPC, servidor OpenAPI, Kafka y TLS nativo

17 de junio de 2026 · Versiones

sgcWebSockets 2026.6 es una de las mayores versiones de la historia de la biblioteca. Incorpora tres clientes totalmente nuevos (un cliente gRPC nativo, un cliente de Apache Kafka y un servidor OpenAPI 3 independiente), dos backends TLS nativos del sistema operativo que permiten que tus aplicaciones móviles y de escritorio se distribuyan sin OpenSSL, un motor de detección de bots solo de clasificación en el firewall, un transporte stdio para MCP destinado a agentes de IA, un conjunto de primitivas criptográficas poscuánticas y un amplio refuerzo de seguridad en los servidores WebSocket y HTTP.

Esta entrada es un recorrido guiado por lo más destacado, con un breve fragmento de Delphi para cada función y un enlace al artículo específico donde cada característica se trata en profundidad.

Cliente gRPC sobre HTTP/2

El nuevo TsgcGRPCClient es un cliente gRPC nativo construido sobre el ya existente TsgcHTTP2Client, sin ningún runtime de gRPC externo que desplegar. Admite los cuatro patrones de RPC (unario, streaming del servidor, streaming del cliente y streaming bidireccional), opciones de canal para compresión y content-type, metadatos predeterminados y por llamada, deadlines, reintentos automáticos con backoff exponencial, balanceo de carga en el cliente (Pick First y Round Robin), gRPC Health Checking, Server Reflection, interceptores y métricas de 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;

Además del cliente genérico, 2026.6 incluye interfaces gRPC tipadas para ocho servicios de Google Cloud, cada uno con clases de petición y respuesta protobuf y autenticación JWT de cuenta de servicio: Pub/Sub, Speech-to-Text, Translation, Vision, Natural Language, Cloud Storage, BigQuery Storage y Vertex AI. Explicación completa: Cliente gRPC para Delphi.

Servidor OpenAPI 3 independiente

TsgcWSAPIServer_OpenAPI convierte una especificación OpenAPI 3 en un servidor REST en funcionamiento. Carga una especificación (o genera una a partir de una clase de Delphi mediante atributos RTTI), adjúntala a un TsgcWebSocketHTTPServer y obtienes enrutamiento, validación de peticiones, Swagger UI y CORS sin esfuerzo adicional. Los fallos de validación devuelven automáticamente 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;

Leer más: Servidor OpenAPI para Delphi.

Cliente de Apache Kafka

TsgcWSPClient_Kafka es un cliente de Apache Kafka nativo que habla el protocolo binario de Kafka sobre TCP en bruto, sin ninguna dependencia de Java o librdkafka. Produce y consume mensajes, suscríbete y haz polling, y gestiona grupos de consumidores, topics y 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;

Leer más: Cliente de Apache Kafka para Delphi.

TLS nativo en Android y Apple, sin OpenSSL que desplegar

Dos nuevos backends TLS ejecutan el handshake a través del sistema operativo en lugar de OpenSSL, de modo que tu aplicación no distribuye ningún libssl.so / libcrypto.so en Android ni ningún .dylib en iOS y macOS. Ambos se seleccionan por plataforma mediante TLSOptions.IOHandler y reutilizan la misma API de TLSOptions que ya usas (CA personalizada, certificado de cliente, ALPN).

Android (iohAndroidTLS) ejecuta TLS a través del javax.net.ssl.SSLEngine de la plataforma vía JNI, valida contra el almacén de confianza del sistema de Android con verificación del nombre de host, negocia TLS 1.3 y admite ALPN en Android 10 y posteriores. Requiere 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) selecciona automáticamente Network.framework para TLS 1.3 en macOS 10.14+ e iOS 12+, y recurre a Secure Transport (TLS 1.2) en sistemas más antiguos. Usa el almacén de confianza del sistema con SNI y verificación del nombre de host, y expone el evento OnAppleTLSVerifyPeer para validación personalizada. Requiere RAD Studio XE6+.

uses
  sgcWebSocket, sgcWebSocket_Types;

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

Leer más: TLS nativo en Android y TLS nativo en Apple.

Detección de bots en el firewall

TsgcWebSocketFirewall incorpora un módulo de detección de bots basado en IP que clasifica un cliente como rastreador de buscador verificado, rango de centro de datos o dirección en lista de bloqueo, usando listas CIDR de bots conocidos, rangos ASN de centros de datos, DNS inverso confirmado hacia adelante (FCrDNS) y consultas DNSBL. Es solo de clasificación: el resultado se expone a través del nuevo evento OnBotDetected y el método GetBotClassification, de modo que eres tú quien decide qué hacer con él en lugar de que el firewall bloquee las conexiones por ti.

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

Esta versión también lleva IPv6 completo al firewall: coincidencia CIDR de listas negras y blancas hasta /128, bloqueos de países IPv6 de GeoLite2, rangos de bots IPv6 y DNS inverso / DNSBL sobre ip6.arpa. Se corrige un error de larga data por el cual un CIDR IPv6 se evaluaba con aritmética de 32 bits (y por tanto coincidía con todos los clientes IPv6). Leer más: Detección de bots en el firewall.

Transporte stdio para MCP

El servidor y el cliente del Model Context Protocol ya pueden funcionar sobre la entrada/salida estándar mediante el nuevo host TsgcAI_MCP_Server_Stdio, de modo que tu servidor MCP de Delphi puede ser lanzado como un subproceso local por agentes de IA como Claude Code. Las herramientas se registran exactamente igual que en el servidor 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.

Leer más: Transporte stdio para MCP en servidor y cliente.

Reforzado por defecto

2026.6 cierra un lote de problemas de denegación de servicio y de conformidad de protocolo en los servidores, y expone los nuevos límites como propiedades con valores predeterminados seguros.

Los servidores WebSocket ahora acotan la memoria de los mensajes con MaxMessageSize (predeterminado 64 MB, 0 = ilimitado), rechazando mensajes sobredimensionados, fragmentación interminable y "bombas zip" de permessage-deflate con el cierre 1009. Las nuevas SecurityOptions.EnforceWebSocketVersion y SecurityOptions.ValidateWebSocketKey validan el handshake de RFC 6455, ambas habilitadas por defecto.

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;

El servidor HTTP añade MaxRequestBodySize (predeterminado 64 MB) y StrictRequestParsing (predeterminado True, que rechaza una petición que lleva a la vez Content-Length y Transfer-Encoding). Se corrige el path traversal en el servicio de archivos estáticos, se mitiga HTTP/2 Rapid Reset (CVE-2023-44487) con límites de RST_STREAM y de tramas de control por conexión, y los archivos de DocumentRoot ahora se transmiten desde el disco con un TFileStream compartido en lugar de cargarse por completo en memoria, de modo que la RAM del servidor se mantiene estable independientemente del tamaño del archivo o del número de conexiones.

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

Leer más: Refuerzo del servidor WebSocket y Refuerzo del servidor HTTP.

Criptografía poscuántica y AEAD

Para las aplicaciones que construyen handshakes poscuánticos híbridos, 2026.6 añade encapsulación y desencapsulación ML-KEM-768 (sgcKEM_MLKEM768_Encapsulate / Decapsulate, OpenSSL 3.5+) junto a un ECDH clásico como KEM sobre P-256 (sgcKEM_ECDH_P256_Encapsulate / Decapsulate) que comparte la misma forma de API de TBytes, de modo que puedes alternar entre KEM clásicos y poscuánticos sin cambiar tu código.

Una nueva unidad sgcSSL_AEAD proporciona primitivas AEAD genéricas (sgcAEAD_Encrypt / sgcAEAD_Decrypt) para AES-128-GCM, AES-256-GCM y ChaCha20-Poly1305, con un nonce de 12 bytes proporcionado por el llamante y AAD arbitrario. Los envoltorios sgcAEAD_EncryptPrefixed / sgcAEAD_DecryptPrefixed producen y consumen el blob autocontenido "nonce(12) || ciphertext || tag(16)" que usan Bouncy Castle GCM, JOSE A256GCM, libsodium y la mayoría de protocolos de estilo 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 descargas de la cuenta

Una nueva API REST en tu cuenta de eSeGeCe te permite iniciar sesión, listar y descargar los archivos a los que da derecho tu suscripción, directamente desde scripts o CI. Está descrita con OpenAPI 3.0 y se distribuye con un cliente Delphi listo para usar construido sobre sgcOpenAPI.

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

Leer más: Automatiza tus descargas con la API de la cuenta.

También en esta versión

El instalador incorpora una opción Include Resources: desmárcala para anular la definición de SGC_RESOURCES antes de la compilación y eliminar el recurso JS embebido, reduciendo el tamaño de la aplicación.
MQTT 5.0: se corrigieron los identificadores de las propiedades Subscription Identifier y Server Reference, que los pares 5.0 estrictos podían rechazar.
AMQP 1.0: los mensajes grandes ahora se dividen en varias tramas cuando superan el max-frame-size negociado.
STOMP: se corrigió una inundación de heartbeats cuando la configuración predeterminada dejaba el intervalo de salida en 0.
Server-Sent Events: el valor de reintento de respaldo ahora se envía en milisegundos, no multiplicado por 1000.
STUN / TURN: id de transacción de 96 bits criptográficamente aleatorio completo, y la longitud de ChannelData ahora excluye el relleno conforme a RFC 5766.
APIs de exchanges: correcciones para las suscripciones de streams de Bybit, Kraken y MEXC. Se ha eliminado el cliente FXCM retirado.
Options.WriteTimeOut ahora funciona en Linux y otras plataformas POSIX (SO_SNDTIMEO se pasa como timeval), de modo que un cliente que lee lento ya no bloquea un hilo del servidor indefinidamente.

Actualización

2026.6 es una actualización directa para los proyectos 2026.x existentes. El refuerzo del servidor se distribuye con valores predeterminados seguros, así que lo único a tener en cuenta es el valor predeterminado de 64 MB de MaxMessageSize / MaxRequestBodySize: si tu aplicación intercambia legítimamente cargas mayores, aumenta el límite (o ponlo a 0 para ilimitado) para igualar tu comportamiento anterior.

Los clientes con una suscripción activa pueden descargar la nueva compilación desde el área de clientes, o desde esegece.com/products/websockets/download.

¿Preguntas, comentarios o ayuda con la migración? Ponte en contacto. Recibirás respuesta de las personas que escribieron el código.