Incluso da sgcWebSockets Standard Disponibile anche in versione autonoma

sgcCrypto — una libreria di crittografia moderna per Delphi e C++ Builder

43 unità Object Pascal pure, nessun componente, nessuna impronta a design-time: passi TBytes in ingresso, ricevi TBytes in uscita. AES-GCM e ChaCha20-Poly1305 per la crittografia, SHA-3/BLAKE2/Argon2 per l'hashing, Ed25519/X25519/RSA per firme e scambio di chiavi, analisi e generazione di certificati X.509, e i post-quantum ML-KEM, ML-DSA e SLH-DSA, le cui chiavi e certificati finiscono negli stessi file X.509, PKCS#8 e PEM di tutto il resto. Il pacchetto include anche un motore TLS 1.3 e TLS 1.2 scritto nello stesso Object Pascal, selezionabile con iohNativeTLS, con lo scambio di chiavi ibrido X25519MLKEM768 attivo per impostazione predefinita. Ogni primitiva è implementata direttamente nell'unità che aggiungi alla tua clausola uses: nessuna DLL esterna, nessun binding OpenSSL, e lo stesso sorgente compila invariato da Delphi 7 a RAD Studio 13. sgcCrypto viene distribuito gratuitamente con sgcWebSockets Standard, Professional ed Enterprise, ed è venduto anche in autonomo (con il runtime sgcWebSockets Core incluso) per i clienti che possiedono solo Core.

Codice sorgente completo
Win32, Win64, Linux64, macOS, iOS e Android
Delphi 7 → 13, invariato
Zero dipendenze esterne
43 funzioni pure sgcCrypto_*.pas Nessun componente. Chiama una funzione, ricevi byte in cambio.
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

Guarda sgcCrypto in due minuti

Crittografia moderna per Delphi: AES-GCM, SHA-3, Ed25519, X.509 e ML-KEM post-quantistico, senza DLL OpenSSL da distribuire.

43 Unità a funzioni pure sgcCrypto_*.pas, zero componenti
6 Famiglie di capacità Simmetrica, hashing, firme, PKI, PQC, OTP
6 Piattaforme di destinazione Win32, Win64, Linux64, macOS, iOS, Android
3 Standard FIPS post-quantum ML-KEM (203), ML-DSA (204), SLH-DSA (205)
2 Modi per possederlo Incluso in un'edizione, oppure autonomo

Tre cose che vale la pena sapere subito

Cosa sia sgcCrypto, se lo possiedi già, e dove funziona. Tutte e tre le risposte sono brevi.

sgcCrypto è fatto di funzioni pure, non di componenti

Ognuna delle 43 unità esporta semplici funzioni e procedure. Non esiste una classe Tsgc*, niente viene registrato con RegisterComponents, e non esiste un sgcCrypto_Reg.pas. Chiami sgcAES_GCM_Encrypt(aKey, aIV, aPlain, aAAD, aTag) allo stesso modo in cui chiameresti qualsiasi funzione della RTL, da una form, un servizio, un'app console o un thread.

Il codice sorgente completo è incluso in ogni licenza, così le primitive si possono seguire passo passo nel tuo debugger invece di sparire dentro un binario o una DLL.

Sovrapposizione con le edizioni

Possiedi già un'edizione di sgcWebSockets?

sgcCrypto è incluso in sgcWebSockets Standard, Professional ed Enterprise, e in All-Access, senza costi aggiuntivi. Se possiedi già una licenza di qualsiasi edizione da Standard in su, hai già tutte le 43 unità, niente altro da acquistare.

sgcCrypto esiste in versione autonoma per il caso opposto: possiedi solo sgcWebSockets Core, o nessuna licenza sgcWebSockets, e vuoi le unità di crittografia senza acquistare la licenza di un'intera edizione.

Ambito delle piattaforme

sgcCrypto non ha alcuna restrizione di piattaforma

A differenza dei pacchetti AI o speech, niente in sgcVer.inc limita sgcCrypto a Windows. Le unità sono ordinaria aritmetica Object Pascal, quindi compilano per Win32, Win64, Linux64, macOS, iOS e Android dallo stesso sorgente.

L'unica unità sensibile alla piattaforma, sgcCrypto_Random, seleziona un backend CSPRNG per ogni target (BCryptGenRandom su Windows, oppure /dev/urandom altrove) dietro la stessa chiamata sgcRandomBytes, così il tuo codice non deve mai diramarsi in base alla piattaforma.

43 unità, sei famiglie di capacità

Ogni unità è Object Pascal compilato, richiamabile da qualsiasi progetto Delphi 7-13 o C++ Builder. Non c'è nessuna DLL esterna, nessun binding OpenSSL e nessun generatore di codice: le primitive sono implementate direttamente nell'unità che aggiungi alla tua clausola uses.

Simmetrica5 unità

AES, ChaCha20 e le costruzioni AEAD sopra di essi

sgcCrypto_AES copre CBC, GCM e CTR; sgcCrypto_Modes aggiunge ECB, OFB, CFB, il ciphertext stealing CTS, AES-CCM, e AES Key Wrap / Key Wrap with Padding (RFC 3394 / 5649); sgcCrypto_CMAC è AES-CMAC e AES-GMAC. sgcCrypto_ChaCha implementa ChaCha20, XChaCha20, Salsa20 e XSalsa20, e sgcCrypto_Poly1305 li abbina a Poly1305 nei cifrari AEAD ChaCha20-Poly1305 e XChaCha20-Poly1305 di RFC 8439. AES-CCM è l'AEAD che Zigbee, Bluetooth e le cipher suite TLS CCM indicano per nome, poiché non richiede nulla oltre al block cipher stesso, e CBC ed ECB accettano entrambi lo schema di padding a scelta, PKCS#7, ANSI X9.23, ISO 7816-4 e gli altri, per il giorno in cui si deve leggere ciò che un altro sistema ha scritto. sgcAES_GCM_Decrypt e i verificatori Poly1305 confrontano il tag di autenticazione in tempo costante e rifiutano di restituire il testo in chiaro quando il controllo fallisce.

Hashing e KDF11 unità

SHA-2, SHA-3, BLAKE2, e ogni KDF di uso comune

sgcCrypto_SHA2 e sgcCrypto_Keccak coprono SHA-1/2, SHA-3, SHAKE, cSHAKE e KMAC; sgcCrypto_Blake2b e sgcCrypto_Blake2s aggiungono BLAKE2. sgcCrypto_HMAC è l'autenticazione dei messaggi con chiave. Per trasformare una password in una chiave: sgcCrypto_KDF (PBKDF2), sgcCrypto_HKDF, sgcCrypto_Scrypt e sgcCrypto_Argon2, che implementa tutte e tre le varianti di Argon2, d, i e id, vincitore della Password Hashing Competition. sgcCrypto_SipHash offre un hash veloce con chiave per le chiavi di hash-table, e sgcCrypto_TLSH è un fuzzy hash con una funzione di distanza di similarità, non un digest crittografico, utile per il rilevamento di quasi-duplicati.

Firme e scambio di chiavi10 unità

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

sgcCrypto_Ed25519/Ed448 firmano e verificano; sgcCrypto_X25519/X448 eseguono il corrispondente Diffie-Hellman. sgcCrypto_ECCurves aggiunge ECDSA ed ECDH su sette curve, secp256k1, le tre curve Brainpool e NIST P-256/P-384/P-521, con nonce deterministici RFC 6979 e firme nella forma raw o DER, oltre alla firma Schnorr BIP-340, con le chiavi pubbliche x-only che Taproot, Nostr e Lightning si aspettano. sgcCrypto_EC è la sorella orientata a JOSE: firma e verifica direttamente un JWS, ES256/384/512. sgcCrypto_RSA verifica firme PKCS#1 v1.5 e PSS direttamente da una chiave PEM, e sgcCrypto_RSA_Keys va oltre con la generazione di chiavi a qualsiasi lunghezza in bit, crittografia OAEP e PKCS#1 v1.5, ed esportazione DER/PEM sia nella forma PKCS#1 che in quella PKCS#8 BEGIN PRIVATE KEY. Le chiavi RSA ed EC si importano con la stessa facilità con cui si esportano, DER o PEM, così una chiave generata una volta può essere salvata e ricaricata anziché vivere solo per la durata del processo. sgcCrypto_ECIES completa il quadro con crittografia ibrida seal/open verso una chiave pubblica X25519.

sgcCrypto_Ed25519 sgcCrypto_ECCurves sgcCrypto_RSA_Keys RFC 8032 · RFC 7748 · RFC 8017
PKI5 unità

Leggi, verifica e genera certificati X.509

sgcCrypto_ASN1 legge DER e PEM e analizza chiavi PKCS#1/SEC 1; sgcCrypto_DER scrive ogni tag di cui un certificato o una CSR hanno bisogno. sgcCrypto_X509 analizza un certificato, verifica che sia stato firmato da un dato emittente, percorre e verifica una catena, verifica una CSR, e analizza una CRL per controllare la revoca. sgcCrypto_X509_Gen genera da zero un certificato autofirmato o una CSR PKCS#10, e una CA emette con sgcX509_CreateSigned oppure sgcX509_CreateSignedFromCSR: distinguished name completo di soggetto ed emittente, finestra di validità, flag CA con vincolo di lunghezza del percorso, flag di key usage, OID di extended key usage e subject alternative name, inclusi i SAN di indirizzo IP, che ora accettano IPv6 in qualsiasi forma testuale della RFC 4291, e i SAN URI per le identità di servizio in stile SPIFFE.

La firma non è più limitata a RSA ed EC. sgcX509_MLDSAKey e sgcX509_SLHDSAKey incapsulano una chiave post-quantum per sgcX509_CreateSelfSignedEx e sgcX509_CreateCSREx, così un certificato o una CSR possono essere firmati con ML-DSA oppure SLH-DSA. Una CA può anche certificare una chiave pubblica ML-KEM (RFC 9935), che non può firmare, quindi il possesso va dimostrato in un altro modo. Sul lato della lettura TsgcX509PublicKeyType ha acquisito x509pkMLDSA, x509pkSLHDSA e x509pkMLKEM, e sgcX509_VerifyChain applica ora la lunghezza del percorso di basicConstraints e l'estensione nameConstraints su dNSName, iPAddress, rfc822Name, uniformResourceIdentifier e directoryName, scritta sul lato della generazione a partire da PermittedDNSNames, ExcludedDNSNames, PermittedIPRanges ed ExcludedIPRanges. Un certificato EC risulta comunque all'incirca un terzo della dimensione di uno RSA e verifica molto più velocemente, il motivo per cui le nuove implementazioni scelgono EC.

sgcCrypto_X509 sgcCrypto_X509_Gen sgcCrypto_ASN1 RFC 5280 · RFC 2986 · RFC 9881 · RFC 9909 · RFC 9935
Post-quantum6 unità

ML-KEM, ML-DSA e SLH-DSA, più un combinatore ibrido

sgcCrypto_MLKEM è l'incapsulamento di chiavi FIPS 203, tre parameter set (ML-KEM-512/768/1024), con rifiuto implicito su un ciphertext malformato. sgcCrypto_MLDSA è la firma FIPS 204, ML-DSA-44/65/87. sgcCrypto_SLHDSA è FIPS 205, tutti e sei i parameter set SHAKE: 128s, 128f, 192s, 192f, 256s, 256f. Poiché ML-KEM da solo punta tutto su un'ipotesi reticolare più giovane delle curve ellittiche, sgcCrypto_MLKEM_Hybrid combina un segreto X25519 e un segreto ML-KEM in un'unica chiave condivisa, così il risultato non è mai più debole della metà classica, lo schema di migrazione verso cui l'industria sta convergendo.

La stessa unità implementa X-Wing (draft-connolly-cfrg-xwing-kem-10), X25519 con ML-KEM-768 come un unico KEM: chiave pubblica di 1216 byte, chiave privata di 32 byte (il seed), ciphertext di 1120 byte e segreto condiviso di 32 byte, tramite sgcXWing_GenerateKeyPair, sgcXWing_Encapsulate e sgcXWing_Decapsulate. Costruisce anche le key share ibride TLS 1.3 della RFC 10024 per X25519MLKEM768, SecP256r1MLKEM768 e SecP384r1MLKEM1024 (codepoint IANA 0x11EC, 0x11EB e 0x11ED). Questi tre non sono KEM a sé stanti, servono soltanto a costruire una key share TLS.

Tutti e tre gli algoritmi ora leggono e scrivono le chiavi come SubjectPublicKeyInfo X.509, OneAsymmetricKey PKCS#8 e PEM, così una chiave post-quantum vive negli stessi file di una chiave RSA o EC. Le chiavi private ML-DSA e ML-KEM hanno tre forme, scelte con TsgcPQCPrivateKeyFormat: pqkfSeed scrive solo il seed (32 byte per ML-DSA, il seed d||z di 64 byte per ML-KEM), pqkfExpanded scrive la chiave espansa, pqkfBoth le contiene entrambe. SLH-DSA ha un'unica forma di chiave privata. sgcMLDSA_GenerateKeyPairAndSeed e sgcMLKEM_GenerateKeyPairAndSeed restituiscono il seed insieme alla coppia di chiavi, così un file in forma seed può essere scritto subito dopo la generazione.

sgcCrypto_MLKEM sgcCrypto_MLDSA sgcCrypto_SLHDSA sgcCrypto_MLKEM_Hybrid FIPS 203 · FIPS 204 · FIPS 205 · RFC 10024
OTP e varie6 unità

Password monouso, codifica, e voci ZIP crittografate

sgcCrypto_OTP genera e verifica codici HOTP e TOTP, gli stessi codici a sei cifre che mostra un'app di autenticazione, con una finestra di verifica in tempo costante che assorbe lo sfasamento dell'orologio. sgcCrypto_Encoding contiene le funzioni di utilità condivise dal resto della libreria: confronto in tempo costante, azzeramento sicuro dei buffer, hex, Base64url e Base32. sgcCrypto_Zip_AE2 implementa la crittografia AES di WinZip, AE-1 e AE-2, per crittografare singole voci ZIP. sgcCrypto_Random è il CSPRNG multipiattaforma dietro ogni chiave e nonce generati altrove nella libreria, e sgcCrypto_Legacy mantiene disponibili MD4/MD5/HMAC-MD5/DES-ECB per l'interoperabilità con formati più vecchi, non per nuovi progetti.

Un motore TLS 1.3 e TLS 1.2 nello stesso Object Pascal

Il pacchetto include anche un'implementazione di TLS 1.3 e TLS 1.2 scritta sopra le primitive di sgcCrypto. Vive nelle unità sgcSSL_NativeTLS* e non in sgcCrypto_*, quindi non è una delle 43, e viene distribuita ovunque venga distribuito sgcCrypto. Selezionalo con una sola proprietà su qualsiasi client o server sgcWebSockets e non c'è nulla da distribuire, su nessuna piattaforma.

// 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;
Scambio di chiavi post-quantum pronto all'uso

L'elenco predefinito dei gruppi inizia con X25519MLKEM768, l'ibrido della RFC 10024 tra X25519 e ML-KEM-768, quindi un handshake con un peer che lo supporta è già post-quantum senza alcuna configurazione. SecP256r1MLKEM768 e SecP384r1MLKEM1024 sono disponibili nello stesso elenco.

Niente da distribuire, su qualsiasi target

Nessuna libssl, nessuna libcrypto, nessun SChannel e nessuno stack TLS di piattaforma, soltanto lo stesso Object Pascal su Win32, Win64, Linux64, macOS, iOS e Android. Imposta TLSOptions.IOHandler := iohNativeTLS su un client, oppure SSLOptions.IOHandler := iohNativeTLS su un server, motori server IOCP ed EPOLL inclusi.

Le radici di cui la macchina si fida già

Imposta NativeTLS_Options.UseSystemRoots su True e il motore aggiunge le radici di fiducia del sistema operativo a RootCertFile: l'archivio ROOT su Windows, e su qualsiasi altra piattaforma il primo file di bundle di CA trovato tra le posizioni standard. Non legge mai il portachiavi di macOS o iOS né l'archivio di Android. È disattivato per impostazione predefinita, quindi le ancore restano esattamente quelle indicate da RootCertFile. Su un server la stessa proprietà si applica ai certificati client che verifica.

Conosci i limiti prima di passare

Il motore parla solo TLS 1.3 e TLS 1.2, senza TLS 1.1, TLS 1.0 o SSL, e i gruppi ibridi post-quantum esistono solo in TLS 1.3, quindi una connessione TLS 1.2 usa X25519, secp256r1 o secp384r1. Non c'è ripresa di sessione né PSK, niente 0-RTT e niente QUIC. La revoca e le policy dei certificati non vengono verificate, e l'evento del componente OnSSLVerifyPeer non è disponibile per esso, il motore ha i propri hook di verifica. Resta su OpenSSL o su un backend di piattaforma quando ti serve una di queste cose.

Nessun componente, nessun Object Inspector

Aggiungi un'unità a uses e chiama una funzione. Ogni chiamata qui sotto proviene da una diversa delle 43 unità, spaziando tra simmetrica, hashing, firme e post-quantum.

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);
Tempo costante dove conta

I controlli dei tag, la verifica HOTP/TOTP e sgcConstantTimeEquals confrontano in tempo costante, e lo stesso vale per il lavoro sul segreto. AES gira su un core bitsliced che non indicizza mai la memoria con un byte segreto né si ramifica su di esso, GHASH moltiplica sotto una maschera, e le operazioni private RSA sono accecate e verificate rispetto all'esponente pubblico prima che venga restituito qualcosa. La firma ECDSA, ECDH e la generazione di chiavi EC usano una moltiplicazione scalare in tempo costante, e la firma Ed25519 legge lo scalare in finestre fisse con una formula di addizione completa.

Rifiuto implicito e input verificati per primi

Un ciphertext della lunghezza giusta che non si decifra produce un segreto pseudocasuale invece di un errore, rifiuto implicito secondo FIPS 203, così un attaccante non ne ricava nulla. Una chiave pubblica malformata, un ciphertext o una chiave di dimensione errata, e una chiave privata che non supera il controllo dell'hash vengono rifiutati prima di qualsiasi calcolo, e una chiave privata ML-KEM, ML-DSA o SLH-DSA importata viene verificata per coerenza, così una chiave le cui parti non appartengono insieme non può essere caricata per errore.

Delphi 7-13, invariato

Non si assume alcun tipo intero nativo a 64 bit. sgcCrypto_Int64 e TsgcBigInt emulano l'aritmetica di cui hanno bisogno gli hash, le curve e le unità post-quantum, così lo stesso sorgente compila su ogni versione supportata.

Niente esce dal tuo processo

Ogni funzione viene eseguita in-process sui dati che passi. Non c'è nessuna chiamata di rete, nessuna telemetria e nessun relay eSeGeCe da nessuna parte nella libreria.

Incluso, oppure un pacchetto autonomo

sgcCrypto viene distribuito gratuitamente con sgcWebSockets Standard, Professional ed Enterprise. Se possiedi solo sgcWebSockets Core, è venduto anche come pacchetto a sé, a partire da €149 per un singolo sviluppatore. Tutte le licenze includono codice sorgente completo, 1 anno di aggiornamenti e uno sconto di rinnovo dal 50% al 70%: il 50% se rinnovi un pacchetto, il 60% per due, il 70% per tre o più.

sgcCrypto

€149

Pacchetto autonomo. Licenze Single, Team e Site disponibili. Gratuito se possiedi già sgcWebSockets Standard, Professional o Enterprise.

  • Tutte le 43 unità sgcCrypto_*.pas
  • Runtime sgcWebSockets Core incluso
  • Delphi e C++ Builder, tutte e sei le piattaforme
  • Codice sorgente completo
  • 1 anno di aggiornamenti

Sei già su sgcWebSockets Standard, Professional o Enterprise? sgcCrypto è già nel tuo installer, nessun ordine necessario.

Vedi prezzi e ordina
3,000+Sviluppatori
20+Anni
761+Componenti
30+Integrazioni API
5Piattaforme
Garanzia soddisfatti o rimborsati di 30 giorniNon sei soddisfatto? Richiedi un rimborso completo entro 30 giorni dall'acquisto. Vedi la politica di rimborso

Crittografia senza il sovraccarico dei componenti

43 funzioni pure che coprono crittografia, hashing, firme, PKI e scambio di chiavi post-quantum, più un motore TLS 1.3 e TLS 1.2 costruito su di esse, pronte ovunque giri già il tuo codice Delphi o C++ Builder. Codice sorgente completo, nessun relay, nessuna DLL.

Altri prodotti eSeGeCe

Abbina sgcCrypto alle nostre altre librerie di componenti per Delphi e C++ Builder.

sgcWebSockets

Componenti Enterprise per WebSocket, HTTP/2, MQTT, AMQP e WebRTC. Standard, Professional ed Enterprise includono tutti sgcCrypto.

Scopri di più →

sgcSign

Firme digitali Enterprise. XAdES, PAdES, CAdES e ASiC con 10 provider di chiavi e 21 profili per paese UE.

Scopri di più →

sgcAuth

Componenti client OAuth2 e JWT, più accesso con passkey WebAuthn. Autonomo, il runtime sgcWebSockets Core è incluso.

Scopri di più →

sgcQUIC

Componenti client e server QUIC (RFC 9000) e HTTP/3 (RFC 9114) costruiti sul motore QUIC nativo di OpenSSL 3.5.

Scopri di più →

sgcAI

Componenti AI, LLM e MCP. Un solo componente chat raggiunge OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok e Mistral.

Scopri di più →

sgcMQ

Componenti client nativi MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka e STOMP, con il runtime Core incluso.

Scopri di più →

sgcOpenAPI

Parser OpenAPI 3.0 e generatore di SDK. Trasforma qualsiasi specifica OpenAPI in un client Delphi fortemente tipizzato in pochi secondi.

Scopri di più →