Incluido desde sgcWebSockets Standard También se vende por separado

sgcCrypto — una biblioteca criptográfica moderna para Delphi y C++ Builder

43 unidades en Object Pascal puro, sin componentes, sin huella en tiempo de diseño: pasas TBytes como entrada y recibes TBytes como salida. AES-GCM y ChaCha20-Poly1305 para cifrado, SHA-3/BLAKE2/Argon2 para hash, Ed25519/X25519/RSA para firmas e intercambio de claves, análisis y generación de certificados X.509, y criptografía poscuántica ML-KEM, ML-DSA y SLH-DSA, cuyas claves y certificados van a los mismos ficheros X.509, PKCS#8 y PEM que todo lo demás. El paquete lleva además un motor TLS 1.3 y TLS 1.2 escrito en el mismo Object Pascal, seleccionado con iohNativeTLS, con intercambio de claves híbrido X25519MLKEM768 activado por defecto. Cada primitiva está implementada directamente en la unidad que añades a tu cláusula uses: sin DLL externa, sin enlace a OpenSSL, y el mismo código fuente compila sin cambios desde Delphi 7 hasta RAD Studio 13. sgcCrypto se distribuye gratis con sgcWebSockets Standard, Professional y Enterprise, y también se vende por separado (incluyendo el runtime de sgcWebSockets Core) para los clientes que solo tienen Core.

Código fuente completo
Win32, Win64, Linux64, macOS, iOS y Android
Delphi 7 → 13, sin cambios
Cero dependencias externas
43 funciones puras sgcCrypto_*.pas Sin componentes. Llama a una función, recibe bytes.
AES-GCM sgcAES_GCM_Encrypt
ChaCha20-Poly1305 sgcChaCha20Poly1305_Encrypt
SHA-3 / SHAKE sgcSHA3_256
Ed25519 / X25519 sgcEd25519_Sign
RSA-PSS sgcRSA_PSS_Sign
ML-KEM / ML-DSA sgcMLKEM_Encapsulate
X.509 / CSR sgcX509_CreateSelfSigned

sgcCrypto en dos minutos

Criptografía moderna para Delphi: AES-GCM, SHA-3, Ed25519, X.509 y ML-KEM poscuántico, sin DLLs de OpenSSL que distribuir.

43 Unidades de funciones puras sgcCrypto_*.pas, cero componentes
6 Familias de funcionalidades Simétrico, hash, firmas, PKI, PQC, OTP
6 Plataformas de destino Win32, Win64, Linux64, macOS, iOS, Android
3 Estándares FIPS poscuánticos ML-KEM (203), ML-DSA (204), SLH-DSA (205)
2 Formas de conseguirlo Incluido en una edición, o independiente

Tres cosas que conviene saber antes

Qué es sgcCrypto, si ya lo tienes incluido, y dónde funciona. Las tres respuestas son breves.

sgcCrypto son funciones puras, no componentes

Cada una de las 43 unidades exporta funciones y procedimientos normales. No hay ninguna clase Tsgc*, nada se registra con RegisterComponents, y no existe un sgcCrypto_Reg.pas. Llamas a sgcAES_GCM_Encrypt(aKey, aIV, aPlain, aAAD, aTag) igual que llamarías a cualquier función de la RTL, desde un formulario, un servicio, una aplicación de consola o un hilo.

El código fuente completo se incluye en todas las licencias, de modo que las primitivas se pueden depurar paso a paso en tu propio depurador en lugar de desaparecer dentro de un binario o una DLL.

Solapamiento de edición

¿Ya tienes una edición de sgcWebSockets?

sgcCrypto viene incluido dentro de sgcWebSockets Standard, Professional y Enterprise, y dentro de All-Access, sin coste adicional. Si ya tienes una licencia de cualquier edición desde Standard, ya dispones de las 43 unidades, no hay nada más que comprar.

sgcCrypto existe como paquete independiente para el caso contrario: solo tienes sgcWebSockets Core, o ninguna licencia de sgcWebSockets, y quieres las unidades de criptografía sin licenciar una edición completa.

Alcance de plataformas

sgcCrypto no lleva ninguna restricción de plataforma

A diferencia de los paquetes de IA o de voz, nada en sgcVer.inc restringe sgcCrypto a Windows. Las unidades son aritmética Object Pascal corriente, así que compilan para Win32, Win64, Linux64, macOS, iOS y Android a partir del mismo código fuente.

La única unidad que distingue la plataforma, sgcCrypto_Random, selecciona un backend CSPRNG según el destino (BCryptGenRandom en Windows, o /dev/urandom en el resto) detrás de la misma llamada sgcRandomBytes, de modo que tu código nunca tiene que bifurcar según la plataforma.

43 unidades, seis familias de funcionalidades

Cada unidad es Object Pascal compilado, invocable desde cualquier proyecto de Delphi 7 a 13 o de C++ Builder. No hay DLL externa, ni enlace a OpenSSL, ni generador de código: las primitivas están implementadas directamente en la unidad que añades a tu cláusula uses.

Simétrico5 unidades

AES, ChaCha20 y las construcciones AEAD que se apoyan en ellos

sgcCrypto_AES cubre CBC, GCM y CTR; sgcCrypto_Modes añade ECB, OFB, CFB, CTS con robo de texto cifrado, AES-CCM, y AES Key Wrap / Key Wrap with Padding (RFC 3394 / 5649); sgcCrypto_CMAC es AES-CMAC y AES-GMAC. sgcCrypto_ChaCha implementa ChaCha20, XChaCha20, Salsa20 y XSalsa20, y sgcCrypto_Poly1305 combina Poly1305 con ellos en los cifrados AEAD ChaCha20-Poly1305 y XChaCha20-Poly1305 de RFC 8439. AES-CCM es el AEAD que nombran Zigbee, Bluetooth y las suites CCM de TLS, ya que no necesita nada más que el propio cifrado de bloque, y tanto CBC como ECB admiten el esquema de relleno que elija, PKCS#7, ANSI X9.23, ISO 7816-4 y el resto, para el día en que tenga que leer lo que escribió otro sistema. sgcAES_GCM_Decrypt y los verificadores de Poly1305 comparan la etiqueta de autenticación en tiempo constante y se niegan a devolver el texto plano cuando falla.

Hash & KDF11 unidades

SHA-2, SHA-3, BLAKE2 y todos los KDF habituales

sgcCrypto_SHA2 y sgcCrypto_Keccak cubren SHA-1/2, SHA-3, SHAKE, cSHAKE y KMAC; sgcCrypto_Blake2b y sgcCrypto_Blake2s añaden BLAKE2. sgcCrypto_HMAC es autenticación de mensajes con clave. Para convertir una contraseña en una clave: sgcCrypto_KDF (PBKDF2), sgcCrypto_HKDF, sgcCrypto_Scrypt y sgcCrypto_Argon2, que implementa las tres variantes de Argon2, d, i e id, la ganadora de la Password Hashing Competition. sgcCrypto_SipHash ofrece un hash con clave rápido para claves de tablas hash, y sgcCrypto_TLSH es un hash difuso con una función de distancia de similitud, no un resumen criptográfico, útil para detectar casi duplicados.

Firmas e intercambio de claves10 unidades

Ed25519/Ed448, X25519/X448, secp256k1, Brainpool y RSA

sgcCrypto_Ed25519/Ed448 firman y verifican; sgcCrypto_X25519/X448 hacen el Diffie-Hellman correspondiente. sgcCrypto_ECCurves añade ECDSA y ECDH sobre siete curvas, secp256k1, las tres curvas Brainpool y NIST P-256/P-384/P-521, con nonces deterministas RFC 6979 y firmas en forma en bruto o DER, además de firma Schnorr BIP-340, con las claves públicas x-only que esperan Taproot, Nostr y Lightning. sgcCrypto_EC es la hermana orientada a JOSE: firma y verifica un JWS directamente, ES256/384/512. sgcCrypto_RSA verifica firmas PKCS#1 v1.5 y PSS directamente desde una clave PEM, y sgcCrypto_RSA_Keys va más allá con generación de claves de cualquier longitud, cifrado OAEP y PKCS#1 v1.5, y exportación DER/PEM tanto en la forma PKCS#1 como en la forma PKCS#8 BEGIN PRIVATE KEY. Las claves RSA y EC se importan con la misma facilidad con la que se exportan, DER o PEM, de modo que una clave generada una vez se puede guardar y volver a cargar en lugar de vivir solo mientras dure el proceso. sgcCrypto_ECIES lo completa con cifrado híbrido seal/open hacia una clave pública X25519.

sgcCrypto_Ed25519 sgcCrypto_ECCurves sgcCrypto_RSA_Keys RFC 8032 · RFC 7748 · RFC 8017
PKI5 unidades

Lee, verifica y genera certificados X.509

sgcCrypto_ASN1 lee DER y PEM y analiza claves PKCS#1/SEC 1; sgcCrypto_DER escribe todas las etiquetas que necesita un certificado o un CSR. sgcCrypto_X509 analiza un certificado, verifica que fue firmado por un emisor dado, recorre y verifica una cadena, verifica un CSR, y analiza una CRL para comprobar la revocación. sgcCrypto_X509_Gen genera desde cero un certificado autofirmado o un CSR PKCS#10, y una CA emite con sgcX509_CreateSigned o sgcX509_CreateSignedFromCSR: nombre distintivo completo de sujeto y emisor, ventana de validez, indicador de CA con restricción de longitud de ruta, indicadores de uso de clave, OID de uso extendido de clave y nombres alternativos del sujeto, incluyendo SAN de direcciones IP, que ahora aceptan IPv6 en cualquier forma de texto del RFC 4291, y SAN de tipo URI para identidades de servicio al estilo SPIFFE.

La firma ya no se limita a RSA y EC. sgcX509_MLDSAKey y sgcX509_SLHDSAKey envuelven una clave poscuántica para sgcX509_CreateSelfSignedEx y sgcX509_CreateCSREx, de modo que un certificado o un CSR pueden firmarse con ML-DSA o SLH-DSA. Una CA también puede certificar una clave pública ML-KEM (RFC 9935), que no puede firmar, así que la posesión hay que demostrarla de otra manera. En el lado de la lectura, TsgcX509PublicKeyType ha ganado x509pkMLDSA, x509pkSLHDSA y x509pkMLKEM, y sgcX509_VerifyChain aplica ahora la longitud de ruta de basicConstraints y la extensión nameConstraints sobre dNSName, iPAddress, rfc822Name, uniformResourceIdentifier y directoryName, escrita en el lado de la generación desde PermittedDNSNames, ExcludedDNSNames, PermittedIPRanges y ExcludedIPRanges. Un certificado EC sigue saliendo con aproximadamente un tercio del tamaño de uno RSA y verifica mucho más rápido, razón por la cual los despliegues nuevos recurren a él.

sgcCrypto_X509 sgcCrypto_X509_Gen sgcCrypto_ASN1 RFC 5280 · RFC 2986 · RFC 9881 · RFC 9909 · RFC 9935
Poscuántica6 unidades

ML-KEM, ML-DSA y SLH-DSA, más un combinador híbrido

sgcCrypto_MLKEM es encapsulación de claves FIPS 203, tres conjuntos de parámetros (ML-KEM-512/768/1024), con rechazo implícito ante un texto cifrado malformado. sgcCrypto_MLDSA es firma FIPS 204, ML-DSA-44/65/87. sgcCrypto_SLHDSA es FIPS 205, los seis conjuntos de parámetros SHAKE: 128s, 128f, 192s, 192f, 256s, 256f. Como ML-KEM por sí solo apuesta todo a una suposición reticular más joven que las curvas elípticas, sgcCrypto_MLKEM_Hybrid combina un secreto X25519 y un secreto ML-KEM en una única clave compartida, de modo que el resultado nunca es más débil que la mitad clásica, el patrón de migración hacia el que converge la industria.

La misma unidad implementa X-Wing (draft-connolly-cfrg-xwing-kem-10), X25519 con ML-KEM-768 como un único KEM: una clave pública de 1216 bytes, una clave privada de 32 bytes (la semilla), un texto cifrado de 1120 bytes y un secreto compartido de 32 bytes, a través de sgcXWing_GenerateKeyPair, sgcXWing_Encapsulate y sgcXWing_Decapsulate. También construye los key shares híbridos de TLS 1.3 del RFC 10024 para X25519MLKEM768, SecP256r1MLKEM768 y SecP384r1MLKEM1024 (puntos de código IANA 0x11EC, 0x11EB y 0x11ED). Esos tres no son KEM independientes, solo construyen un key share de TLS.

Los tres algoritmos leen y escriben ahora las claves como SubjectPublicKeyInfo de X.509, OneAsymmetricKey de PKCS#8 y PEM, así que una clave poscuántica vive en los mismos ficheros que una RSA o EC. Las claves privadas de ML-DSA y ML-KEM tienen tres formas, elegidas con TsgcPQCPrivateKeyFormat: pqkfSeed escribe solo la semilla (32 bytes para ML-DSA, la semilla d||z de 64 bytes para ML-KEM), pqkfExpanded escribe la clave expandida, pqkfBoth lleva las dos. SLH-DSA tiene una única forma de clave privada. sgcMLDSA_GenerateKeyPairAndSeed y sgcMLKEM_GenerateKeyPairAndSeed devuelven la semilla junto con el par de claves, así que se puede escribir un fichero en forma de semilla justo después de generarlo.

sgcCrypto_MLKEM sgcCrypto_MLDSA sgcCrypto_SLHDSA sgcCrypto_MLKEM_Hybrid FIPS 203 · FIPS 204 · FIPS 205 · RFC 10024
OTP y varios6 unidades

Contraseñas de un solo uso, codificación y entradas ZIP cifradas

sgcCrypto_OTP genera y verifica códigos HOTP y TOTP, los mismos códigos de seis dígitos que muestra una app de autenticación, con una ventana de verificación en tiempo constante que absorbe el desfase de reloj. sgcCrypto_Encoding contiene las funciones de utilidad que comparte el resto de la biblioteca: comparación en tiempo constante, puesta a cero segura de buffers, hex, Base64url y Base32. sgcCrypto_Zip_AE2 implementa el cifrado WinZip AES, AE-1 y AE-2, para cifrar entradas individuales de un ZIP. sgcCrypto_Random es el CSPRNG multiplataforma detrás de cada clave y nonce generados en el resto de la biblioteca, y sgcCrypto_Legacy mantiene disponibles MD4/MD5/HMAC-MD5/DES-ECB para interoperar con formatos antiguos, no para diseños nuevos.

Un motor TLS 1.3 y TLS 1.2 en el mismo Object Pascal

El paquete lleva además una implementación de TLS 1.3 y TLS 1.2 escrita sobre las primitivas de sgcCrypto. Vive en las unidades sgcSSL_NativeTLS* y no en sgcCrypto_*, así que no es una de las 43, y se entrega allá donde se entrega sgcCrypto. Selecciónalo con una sola propiedad en cualquier cliente o servidor de sgcWebSockets y no hay nada que desplegar en ninguna plataforma.

// Client: no OpenSSL, no SChannel, no platform TLS stack
WSClient.TLS := True;
WSClient.TLSOptions.IOHandler := iohNativeTLS;
// Lowest version allowed: tls1_2 negotiates TLS 1.3 or TLS 1.2, tls1_3 only TLS 1.3
WSClient.TLSOptions.Version := tls1_2;
WSClient.TLSOptions.RootCertFile := 'roots.pem';
// Optional: also trust the roots the operating system already trusts
WSClient.TLSOptions.NativeTLS_Options.UseSystemRoots := True;

// Both lists are OpenSSL style, colon separated. This group list is the default.
WSClient.TLSOptions.NativeTLS_Options.Groups :=
  'X25519MLKEM768:X25519:secp256r1:secp384r1';
// Only TLS 1.3 suites here means TLS 1.3 only. Leave it empty for the default,
// which adds the TLS 1.2 ECDHE suites with AES-GCM and ChaCha20-Poly1305.
WSClient.TLSOptions.NativeTLS_Options.CipherSuites :=
  'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256';

// Server: the same switch on SSLOptions, IOCP and EPOLL engines included
WSServer.SSLOptions.IOHandler := iohNativeTLS;
Intercambio de claves poscuántico desde el primer momento

La lista de grupos por defecto empieza por X25519MLKEM768, el híbrido de X25519 y ML-KEM-768 del RFC 10024, así que un handshake con un par que lo admita ya es poscuántico sin ninguna configuración. SecP256r1MLKEM768 y SecP384r1MLKEM1024 están disponibles en la misma lista.

Nada que desplegar, en ningún destino

Sin libssl, sin libcrypto, sin SChannel y sin la pila TLS de la plataforma, solo el mismo Object Pascal en Win32, Win64, Linux64, macOS, iOS y Android. Establece TLSOptions.IOHandler := iohNativeTLS en un cliente, o SSLOptions.IOHandler := iohNativeTLS en un servidor, incluidos los motores de servidor IOCP y EPOLL.

Las raíces en las que la máquina ya confía

Establece NativeTLS_Options.UseSystemRoots en True y el motor añade las raíces de confianza del sistema operativo a RootCertFile: el almacén ROOT en Windows, y en cualquier otra plataforma el primer archivo de paquete CA encontrado entre las ubicaciones estándar. Nunca lee el llavero de macOS o iOS ni el almacén de Android. Está desactivado por defecto, así que las anclas de confianza siguen siendo exactamente lo que dice RootCertFile. En un servidor la misma propiedad se aplica a los certificados de cliente que verifica.

Conoce los límites antes de cambiar

El motor solo habla TLS 1.3 y TLS 1.2, sin TLS 1.1, TLS 1.0 ni SSL, y los grupos híbridos poscuánticos solo existen en TLS 1.3, así que una conexión TLS 1.2 usa X25519, secp256r1 o secp384r1. No hay reanudación de sesión ni PSK, ni 0-RTT, ni QUIC. No se comprueban la revocación ni las políticas de certificados, y el evento de componente OnSSLVerifyPeer no está disponible para él, el motor tiene sus propios puntos de enganche de verificación. Sigue con OpenSSL o con un backend de plataforma cuando necesites alguna de esas cosas.

Sin componentes, sin Object Inspector

Añade una unidad a uses y llama a una función. Cada llamada de abajo procede de una unidad distinta de las 43, abarcando simétrico, hash, firmas y poscuántica.

uses
  sgcCrypto_Random, sgcCrypto_AES, sgcCrypto_Keccak, sgcCrypto_Ed25519,
  sgcCrypto_MLKEM;

var
  vKey, vIV, vPlain, vAAD, vTag, vCipher: TBytes;
  vDigest, vSeed, vSignature, vMessage: TBytes;
  vPublicKey, vPrivateKey, vSharedSecret, vCiphertext: TBytes;
begin
  // AES-256-GCM: authenticated encryption in one call
  vKey    := sgcRandomBytes(32);
  vIV     := sgcRandomBytes(12);
  vPlain  := TEncoding.UTF8.GetBytes('confidential payload');
  vCipher := sgcAES_GCM_Encrypt(vKey, vIV, vPlain, vAAD, vTag);

  // SHA-3-256, one call, no context object to manage
  vDigest := sgcSHA3_256(vPlain);

  // Ed25519: sign, then verify
  vSeed      := sgcRandomBytes(32);
  vMessage   := TEncoding.UTF8.GetBytes('sign me');
  vSignature := sgcEd25519_Sign(vSeed, vMessage);

  // ML-KEM-768: post-quantum key encapsulation (FIPS 203)
  sgcMLKEM_GenerateKeyPair(mlkem768, vPublicKey, vPrivateKey);
  sgcMLKEM_Encapsulate(mlkem768, vPublicKey, vCiphertext, vSharedSecret);
end;
// includes: sgcCrypto_Random.hpp, sgcCrypto_AES.hpp, sgcCrypto_Keccak.hpp,
// sgcCrypto_Ed25519.hpp, sgcCrypto_MLKEM.hpp

// AES-256-GCM: authenticated encryption in one call
TBytes vKey    = sgcRandomBytes(32);
TBytes vIV     = sgcRandomBytes(12);
TBytes vAAD, vTag;
TBytes vPlain  = TEncoding::UTF8->GetBytes("confidential payload");
TBytes vCipher = sgcAES_GCM_Encrypt(vKey, vIV, vPlain, vAAD, vTag);

// SHA-3-256, one call, no context object to manage
TBytes vDigest = sgcSHA3_256(vPlain);

// Ed25519: sign, then verify
TBytes vSeed      = sgcRandomBytes(32);
TBytes vMessage   = TEncoding::UTF8->GetBytes("sign me");
TBytes vSignature = sgcEd25519_Sign(vSeed, vMessage);

// ML-KEM-768: post-quantum key encapsulation (FIPS 203)
TBytes vPublicKey, vPrivateKey, vSharedSecret, vCiphertext;
sgcMLKEM_GenerateKeyPair(mlkem768, vPublicKey, vPrivateKey);
sgcMLKEM_Encapsulate(mlkem768, vPublicKey, vCiphertext, vSharedSecret);
Tiempo constante donde importa

Las comprobaciones de etiqueta, la verificación HOTP/TOTP y sgcConstantTimeEquals comparan en tiempo constante, y lo mismo ocurre con el trabajo sobre el secreto. AES se ejecuta sobre un núcleo bitsliced que nunca indexa la memoria con un byte secreto ni se bifurca según uno, GHASH multiplica bajo una máscara, y las operaciones privadas de RSA se ciegan y se comprueban contra el exponente público antes de devolver nada. La firma ECDSA, ECDH y la generación de claves EC usan una multiplicación escalar en tiempo constante, y la firma Ed25519 lee el escalar en ventanas fijas con una fórmula de suma completa.

Rechazo implícito y entradas comprobadas primero

Un texto cifrado de la longitud correcta que no descifra produce un secreto pseudoaleatorio en lugar de un error, rechazo implícito según FIPS 203, de modo que un atacante no aprende nada de él. Una clave pública malformada, un texto cifrado o una clave de tamaño incorrecto, y una clave privada que no supera la comprobación del hash se rechazan antes de cualquier cálculo, y una clave privada ML-KEM, ML-DSA o SLH-DSA importada se comprueba para verificar su coherencia, de modo que una clave cuyas partes no corresponden entre sí no puede cargarse por error.

Delphi 7 a 13, sin cambios

No se asume ningún tipo entero de 64 bits nativo. sgcCrypto_Int64 y TsgcBigInt emulan la aritmética que necesitan las unidades de hash, curvas y poscuánticas, de modo que el mismo código fuente compila en todas las versiones soportadas.

Nada sale de tu proceso

Cada función se ejecuta dentro de tu proceso sobre los datos que le pasas. No hay ninguna llamada de red, ninguna telemetría ni ningún relé de eSeGeCe en ninguna parte de la biblioteca.

Incluido, o como paquete independiente

sgcCrypto se distribuye gratis con sgcWebSockets Standard, Professional y Enterprise. Si solo tienes sgcWebSockets Core, también se vende como paquete independiente, desde €149 para un desarrollador individual. Todas las licencias incluyen código fuente completo, 1 año de actualizaciones y un descuento de renovación del 50% al 70%: 50% al renovar un paquete, 60% por dos, 70% por tres o más.

sgcCrypto

€149

Paquete independiente. Licencias Single, Team y Site disponibles. Gratis si ya tienes sgcWebSockets Standard, Professional o Enterprise.

  • Las 43 unidades sgcCrypto_*.pas
  • Runtime de sgcWebSockets Core incluido
  • Delphi y C++ Builder, las seis plataformas
  • Código fuente completo
  • 1 año de actualizaciones

¿Ya tienes sgcWebSockets Standard, Professional o Enterprise? sgcCrypto ya está en tu instalador, no hace falta pedirlo.

Ver precios y comprar
3,000+Desarrolladores
20+Años
761+Componentes
30+Integraciones de API
5Plataformas
Garantía de devolución de 30 días¿No estás satisfecho? Solicita un reembolso completo en los 30 días posteriores a la compra. Ver política de reembolso

Criptografía sin la sobrecarga de los componentes

43 funciones puras que cubren cifrado, hash, firmas, PKI e intercambio de claves poscuántico, más un motor TLS 1.3 y TLS 1.2 construido sobre ellas, listas allí donde ya se ejecuta tu código Delphi o C++ Builder. Código fuente completo, sin relé, sin DLL.

Otros productos de eSeGeCe

Combina sgcCrypto con nuestras otras bibliotecas de componentes para Delphi y C++ Builder.

sgcWebSockets

Componentes empresariales de WebSocket, HTTP/2, MQTT, AMQP y WebRTC. Standard, Professional y Enterprise incluyen todos sgcCrypto.

Más información →

sgcSign

Firmas digitales empresariales. XAdES, PAdES, CAdES y ASiC con 10 proveedores de claves y 21 perfiles por país de la UE.

Más información →

sgcAuth

Componentes cliente OAuth2 y cliente JWT, además de inicio de sesión con passkey WebAuthn. Como paquete independiente, incluye el runtime de sgcWebSockets Core.

Más información →

sgcQUIC

Componentes cliente y servidor de QUIC (RFC 9000) y HTTP/3 (RFC 9114) construidos sobre el motor QUIC nativo de OpenSSL 3.5.

Más información →

sgcAI

Componentes de IA, LLM y MCP. Un único componente de chat llega a OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok y Mistral.

Más información →

sgcMQ

Componentes cliente nativos de MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka y STOMP, con el runtime de Core incluido.

Más información →

sgcOpenAPI

Parser de OpenAPI 3.0 y generador de SDK. Convierte cualquier especificación OpenAPI en un cliente Delphi fuertemente tipado en segundos.

Más información →