Inclus à partir de sgcWebSockets Standard Aussi vendu seul

sgcCrypto — une bibliothèque de cryptographie moderne pour Delphi et C++ Builder

43 unités Object Pascal pures, aucun composant, aucune empreinte à la conception : passe des TBytes en entrée, récupère des TBytes en sortie. AES-GCM et ChaCha20-Poly1305 pour le chiffrement, SHA-3/BLAKE2/Argon2 pour le hachage, Ed25519/X25519/RSA pour les signatures et l'échange de clés, l'analyse et la génération de certificats X.509, et le post-quantique ML-KEM, ML-DSA et SLH-DSA, dont les clés et les certificats se rangent dans les mêmes fichiers X.509, PKCS#8 et PEM que tout le reste. Le pack embarque aussi un moteur TLS 1.3 et TLS 1.2 écrit dans le même Object Pascal, sélectionné avec iohNativeTLS, avec l'échange de clés hybride X25519MLKEM768 actif par défaut. Chaque primitive est implémentée directement dans l'unité que tu ajoutes à ton uses : aucune DLL externe, aucun binding OpenSSL, et la même source compile sans changement de Delphi 7 à RAD Studio 13. sgcCrypto est livré gratuitement avec sgcWebSockets Standard, Professional et Enterprise, et il est aussi vendu seul (avec le runtime sgcWebSockets Core inclus) pour les clients qui ne possèdent que Core.

Code source complet
Win32, Win64, Linux64, macOS, iOS et Android
Delphi 7 → 13, inchangé
Zéro dépendance externe
43 fonctions pures sgcCrypto_*.pas Aucun composant. Appelle une fonction, récupère des octets.
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

Découvre sgcCrypto en deux minutes

Cryptographie moderne pour Delphi : AES-GCM, SHA-3, Ed25519, X.509 et ML-KEM post-quantique, sans aucune DLL OpenSSL à distribuer.

43 Unités de fonctions pures sgcCrypto_*.pas, zéro composant
6 Familles de fonctionnalités Symétrique, hachage, signatures, PKI, post-quantique, OTP
6 Plateformes cibles Win32, Win64, Linux64, macOS, iOS, Android
3 Normes FIPS post-quantiques ML-KEM (203), ML-DSA (204), SLH-DSA (205)
2 Façons de l'obtenir Incluse dans une édition, ou en autonome

Trois choses à savoir d'abord

Ce qu'est sgcCrypto, si tu le possèdes déjà, et où il tourne. Les trois réponses sont courtes.

sgcCrypto, ce sont des fonctions pures, pas des composants

Chacune des 43 unités exporte de simples fonctions et procédures. Il n'y a aucune classe Tsgc*, rien n'est enregistré via RegisterComponents, et il n'existe aucun sgcCrypto_Reg.pas. Tu appelles sgcAES_GCM_Encrypt(aKey, aIV, aPlain, aAAD, aTag) de la même façon que n'importe quelle fonction de la RTL, depuis une fiche, un service, une application console ou un thread.

Le code source complet est livré avec chaque licence, si bien que les primitives se parcourent pas à pas dans ton propre débogueur au lieu de disparaître dans un binaire ou une DLL.

Chevauchement d'édition

Tu possèdes déjà une édition sgcWebSockets ?

sgcCrypto est livré à l'intérieur de sgcWebSockets Standard, Professional et Enterprise, ainsi que dans All-Access, sans coût supplémentaire. Si tu possèdes déjà une licence pour une édition à partir de Standard, tu as déjà les 43 unités, rien de plus à acheter.

sgcCrypto existe en autonome pour le cas inverse : tu ne possèdes que sgcWebSockets Core, ou aucune licence sgcWebSockets du tout, et tu veux les unités de cryptographie sans licencier une édition complète.

Portée des plateformes

sgcCrypto ne porte aucune restriction de plateforme

Contrairement aux packages IA ou voix, rien dans sgcVer.inc ne restreint sgcCrypto à Windows. Les unités ne sont que de l'arithmétique Object Pascal ordinaire, elles se compilent donc pour Win32, Win64, Linux64, macOS, iOS et Android à partir de la même source.

La seule unité sensible à la plateforme, sgcCrypto_Random, sélectionne un moteur CSPRNG selon la cible (BCryptGenRandom sous Windows, ou /dev/urandom ailleurs) derrière le même appel sgcRandomBytes, ton code ne teste donc jamais la plateforme.

43 unités, six familles de fonctionnalités

Chaque unité est de l'Object Pascal compilé, appelable depuis n'importe quel projet Delphi 7 à 13 ou C++ Builder. Il n'y a aucune DLL externe, aucun binding OpenSSL et aucun générateur de code : les primitives sont implémentées directement dans l'unité que tu ajoutes à ton uses.

Symétrique5 unités

AES, ChaCha20 et les constructions AEAD au-dessus

sgcCrypto_AES couvre CBC, GCM et CTR ; sgcCrypto_Modes ajoute ECB, OFB, CFB, le ciphertext stealing CTS, AES-CCM, et l'AES Key Wrap / Key Wrap with Padding (RFC 3394 / 5649). sgcCrypto_CMAC est l'AES-CMAC et l'AES-GMAC. sgcCrypto_ChaCha implémente ChaCha20, XChaCha20, Salsa20 et XSalsa20, et sgcCrypto_Poly1305 associe Poly1305 avec eux pour former les chiffrements AEAD ChaCha20-Poly1305 et XChaCha20-Poly1305 de la RFC 8439. AES-CCM est l'AEAD que nomment Zigbee, Bluetooth et les suites TLS CCM, puisqu'il ne nécessite rien de plus que le chiffrement par bloc lui-même, et CBC comme ECB acceptent tous deux le schéma de remplissage de ton choix, PKCS#7, ANSI X9.23, ISO 7816-4 et les autres, pour le jour où tu dois lire ce qu'un autre système a écrit. sgcAES_GCM_Decrypt et les vérificateurs Poly1305 comparent le tag d'authentification en temps constant et refusent de renvoyer le texte clair quand la vérification échoue.

Hachage et KDF11 unités

SHA-2, SHA-3, BLAKE2, et tous les KDF courants

sgcCrypto_SHA2 et sgcCrypto_Keccak couvrent SHA-1/2, SHA-3, SHAKE, cSHAKE et KMAC ; sgcCrypto_Blake2b et sgcCrypto_Blake2s ajoutent BLAKE2. sgcCrypto_HMAC gère l'authentification par hachage à clé. Pour transformer un mot de passe en clé : sgcCrypto_KDF (PBKDF2), sgcCrypto_HKDF, sgcCrypto_Scrypt et sgcCrypto_Argon2, qui implémente les trois variantes d'Argon2, d, i et id, la gagnante de la Password Hashing Competition. sgcCrypto_SipHash te donne un hachage à clé rapide pour les clés de table de hachage, et sgcCrypto_TLSH est un hachage flou avec une fonction de distance de similarité, pas un condensé cryptographique, utile pour la détection de quasi-doublons.

Signatures et échange de clés10 unités

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

sgcCrypto_Ed25519/Ed448 signent et vérifient ; sgcCrypto_X25519/X448 font le Diffie-Hellman correspondant. sgcCrypto_ECCurves ajoute ECDSA et ECDH sur sept courbes, secp256k1, les trois courbes Brainpool et NIST P-256/P-384/P-521, avec des nonces déterministes RFC 6979 et des signatures sous forme brute ou DER, plus la signature Schnorr BIP-340 en prime, avec les clés publiques x-only qu'attendent Taproot, Nostr et Lightning. sgcCrypto_EC est la variante orientée JOSE : signe et vérifie un JWS directement, ES256/384/512. sgcCrypto_RSA vérifie des signatures PKCS#1 v1.5 et PSS directement depuis une clé PEM, et sgcCrypto_RSA_Keys va plus loin avec la génération de clés à n'importe quelle longueur, le chiffrement OAEP et PKCS#1 v1.5, et l'export DER/PEM sous forme PKCS#1 et sous forme PKCS#8 BEGIN PRIVATE KEY. Les clés RSA et EC s'importent aussi facilement qu'elles s'exportent, en DER ou en PEM, si bien qu'une clé générée une fois peut être sauvegardée puis rechargée au lieu de ne vivre que le temps du processus. sgcCrypto_ECIES complète le tout avec le chiffrement hybride seal/open vers une clé publique X25519.

sgcCrypto_Ed25519 sgcCrypto_ECCurves sgcCrypto_RSA_Keys RFC 8032 · RFC 7748 · RFC 8017
PKI5 unités

Lire, vérifier et générer des certificats X.509

sgcCrypto_ASN1 lit le DER et le PEM et analyse les clés PKCS#1/SEC 1 ; sgcCrypto_DER écrit chaque tag dont un certificat ou une CSR a besoin. sgcCrypto_X509 analyse un certificat, vérifie qu'il a été signé par un émetteur donné, parcourt et vérifie une chaîne, vérifie une CSR, et analyse une CRL pour vérifier la révocation. sgcCrypto_X509_Gen génère un certificat autosigné ou une CSR PKCS#10 depuis zéro, et une AC émet avec sgcX509_CreateSigned ou sgcX509_CreateSignedFromCSR : nom distinctif complet du sujet et de l'émetteur, fenêtre de validité, indicateur d'AC avec contrainte de longueur de chemin, indicateurs d'usage de clé, OID d'usage étendu de clé et noms alternatifs du sujet, y compris les SAN d'adresse IP, qui acceptent désormais l'IPv6 sous toutes les formes textuelles de la RFC 4291, et les SAN d'URI pour les identités de service de type SPIFFE.

La signature n'est plus limitée à RSA et EC. sgcX509_MLDSAKey et sgcX509_SLHDSAKey enveloppent une clé post-quantique pour sgcX509_CreateSelfSignedEx et sgcX509_CreateCSREx, si bien qu'un certificat ou une CSR peut être signé avec ML-DSA ou SLH-DSA. Une AC peut aussi certifier une clé publique ML-KEM (RFC 9935), qui ne sait pas signer, la possession doit donc être prouvée autrement. Du côté de la lecture, TsgcX509PublicKeyType a gagné x509pkMLDSA, x509pkSLHDSA et x509pkMLKEM, et sgcX509_VerifyChain applique désormais la longueur de chemin de basicConstraints et l'extension nameConstraints sur dNSName, iPAddress, rfc822Name, uniformResourceIdentifier et directoryName, écrite du côté de la génération depuis PermittedDNSNames, ExcludedDNSNames, PermittedIPRanges et ExcludedIPRanges. Un certificat EC ressort toujours environ trois fois plus petit qu'un certificat RSA et se vérifie bien plus vite, ce qui explique pourquoi les nouveaux déploiements y ont recours.

sgcCrypto_X509 sgcCrypto_X509_Gen sgcCrypto_ASN1 RFC 5280 · RFC 2986 · RFC 9881 · RFC 9909 · RFC 9935
Post-quantique6 unités

ML-KEM, ML-DSA et SLH-DSA, plus un combinateur hybride

sgcCrypto_MLKEM est l'encapsulation de clé FIPS 203, trois jeux de paramètres (ML-KEM-512/768/1024), avec rejet implicite sur un texte chiffré malformé. sgcCrypto_MLDSA est la signature FIPS 204, ML-DSA-44/65/87. sgcCrypto_SLHDSA est FIPS 205, les six jeux de paramètres SHAKE : 128s, 128f, 192s, 192f, 256s, 256f. Comme ML-KEM à lui seul mise tout sur une hypothèse de réseau euclidien plus jeune que les courbes elliptiques, sgcCrypto_MLKEM_Hybrid combine un secret X25519 et un secret ML-KEM en une seule clé partagée, si bien que le résultat n'est jamais plus faible que la moitié classique, le schéma de migration vers lequel converge l'industrie.

La même unité implémente X-Wing (draft-connolly-cfrg-xwing-kem-10), X25519 avec ML-KEM-768 comme un seul KEM : une clé publique de 1216 octets, une clé privée de 32 octets (la graine), un texte chiffré de 1120 octets et un secret partagé de 32 octets, via sgcXWing_GenerateKeyPair, sgcXWing_Encapsulate et sgcXWing_Decapsulate. Elle construit aussi les parts de clé hybrides TLS 1.3 de la RFC 10024 pour X25519MLKEM768, SecP256r1MLKEM768 et SecP384r1MLKEM1024 (points de code IANA 0x11EC, 0x11EB et 0x11ED). Ces trois-là ne sont pas des KEM autonomes, ils ne servent qu'à construire une part de clé TLS.

Les trois algorithmes lisent et écrivent désormais les clés en X.509 SubjectPublicKeyInfo, en PKCS#8 OneAsymmetricKey et en PEM, si bien qu'une clé post-quantique vit dans les mêmes fichiers qu'une clé RSA ou EC. Les clés privées ML-DSA et ML-KEM ont trois formes, choisies avec TsgcPQCPrivateKeyFormat : pqkfSeed écrit la graine seule (32 octets pour ML-DSA, la graine d||z de 64 octets pour ML-KEM), pqkfExpanded écrit la clé développée, pqkfBoth porte les deux. SLH-DSA n'a qu'une seule forme de clé privée. sgcMLDSA_GenerateKeyPairAndSeed et sgcMLKEM_GenerateKeyPairAndSeed renvoient la graine en même temps que la paire de clés, de sorte qu'un fichier au format graine peut être écrit juste après la génération.

sgcCrypto_MLKEM sgcCrypto_MLDSA sgcCrypto_SLHDSA sgcCrypto_MLKEM_Hybrid FIPS 203 · FIPS 204 · FIPS 205 · RFC 10024
OTP et divers6 unités

Mots de passe à usage unique, encodage, et ZIP chiffré

sgcCrypto_OTP génère et vérifie les codes HOTP et TOTP, les mêmes codes à six chiffres qu'affiche une application d'authentification, avec une fenêtre de vérification en temps constant qui absorbe le décalage d'horloge. sgcCrypto_Encoding regroupe les fonctions utilitaires que partage le reste de la bibliothèque : comparaison en temps constant, effacement sécurisé de buffer, hex, Base64url et Base32. sgcCrypto_Zip_AE2 implémente le chiffrement WinZip AES, AE-1 et AE-2, pour chiffrer des entrées ZIP individuelles. sgcCrypto_Random est le CSPRNG multiplateforme derrière chaque clé et nonce générés ailleurs dans la bibliothèque, et sgcCrypto_Legacy garde MD4/MD5/HMAC-MD5/DES-ECB disponibles pour l'interopérabilité avec des formats plus anciens, pas pour de nouvelles conceptions.

Un moteur TLS 1.3 et TLS 1.2 dans le même Object Pascal

Le pack embarque aussi une implémentation de TLS 1.3 et TLS 1.2 écrite au-dessus des primitives sgcCrypto. Elle vit dans les unités sgcSSL_NativeTLS* plutôt que dans sgcCrypto_*, elle ne fait donc pas partie des 43, et elle est livrée partout où sgcCrypto l'est. Sélectionne-la avec une seule propriété sur n'importe quel client ou serveur sgcWebSockets, et il n'y a rien à déployer, sur aucune plateforme.

// Client : aucun OpenSSL, aucun SChannel, aucune pile TLS de plateforme
WSClient.TLS := True;
WSClient.TLSOptions.IOHandler := iohNativeTLS;
// Version minimale autorisée : tls1_2 négocie TLS 1.3 ou TLS 1.2, tls1_3 uniquement 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;

// Les deux listes sont au style OpenSSL, séparées par des deux-points. Cette liste de groupes est la valeur par défaut.
WSClient.TLSOptions.NativeTLS_Options.Groups :=
  'X25519MLKEM768:X25519:secp256r1:secp384r1';
// Ne lister ici que des suites TLS 1.3 signifie TLS 1.3 uniquement. Laisse-la vide pour la valeur
// par défaut, qui ajoute les suites ECDHE TLS 1.2 avec AES-GCM et ChaCha20-Poly1305.
WSClient.TLSOptions.NativeTLS_Options.CipherSuites :=
  'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256';

// Serveur : le même commutateur sur SSLOptions, moteurs IOCP et EPOLL compris
WSServer.SSLOptions.IOHandler := iohNativeTLS;
Échange de clés post-quantique dès l'installation

La liste de groupes par défaut commence par X25519MLKEM768, l'hybride X25519 et ML-KEM-768 de la RFC 10024, si bien qu'une négociation avec un pair compatible est déjà post-quantique sans aucune configuration. SecP256r1MLKEM768 et SecP384r1MLKEM1024 sont disponibles dans la même liste.

Rien à déployer, sur aucune cible

Aucun libssl, aucun libcrypto, aucun SChannel et aucune pile TLS de plateforme, juste le même Object Pascal sur Win32, Win64, Linux64, macOS, iOS et Android. Affecte TLSOptions.IOHandler := iohNativeTLS sur un client, ou SSLOptions.IOHandler := iohNativeTLS sur un serveur, moteurs de serveur IOCP et EPOLL compris.

Les racines auxquelles la machine fait déjà confiance

Mets NativeTLS_Options.UseSystemRoots à True et le moteur ajoute les racines de confiance du système d'exploitation à RootCertFile : le magasin ROOT sous Windows, et sur toute autre plateforme le premier fichier bundle de CA trouvé parmi les emplacements standard. Elle ne lit jamais le trousseau macOS ou iOS ni le magasin Android. Elle est désactivée par défaut, si bien que les ancres restent exactement ce que dit RootCertFile. Sur un serveur, la même propriété s'applique aux certificats client qu'il vérifie.

Connais les limites avant de basculer

Le moteur ne parle que TLS 1.3 et TLS 1.2, sans TLS 1.1, TLS 1.0 ni SSL, et les groupes hybrides post-quantiques n'existent qu'en TLS 1.3, si bien qu'une connexion TLS 1.2 utilise X25519, secp256r1 ou secp384r1. Il n'y a ni reprise de session ni PSK, pas de 0-RTT et pas de QUIC. La révocation et les politiques de certificats ne sont pas vérifiées, et l'événement de composant OnSSLVerifyPeer n'est pas disponible pour lui, le moteur possède ses propres points d'accroche de vérification. Reste sur OpenSSL ou sur un backend de plateforme si tu as besoin de l'un de ces éléments.

Aucun composant, aucun Object Inspector

Ajoute une unité à uses et appelle une fonction. Chaque appel ci-dessous provient d'une unité différente parmi les 43, couvrant le symétrique, le hachage, les signatures et le post-quantique.

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);
Temps constant là où ça compte

Les vérifications de tag, la vérification HOTP/TOTP et sgcConstantTimeEquals comparent en temps constant, et il en va de même pour le traitement du secret. AES s'exécute sur un noyau bitsliced qui n'indexe jamais la mémoire avec un octet secret et ne branche jamais sur un tel octet, GHASH multiplie sous un masque, et les opérations privées RSA sont aveuglées et vérifiées par rapport à l'exposant public avant que quoi que ce soit ne soit renvoyé. La signature ECDSA, ECDH et la génération de clés EC utilisent une multiplication scalaire en temps constant, et la signature Ed25519 lit le scalaire par fenêtres fixes avec une formule d'addition complète.

Rejet implicite, et entrées vérifiées d'abord

Un texte chiffré de la bonne longueur qui ne se déchiffre pas produit un secret pseudo-aléatoire au lieu d'une erreur, c'est le rejet implicite selon FIPS 203, si bien qu'un attaquant n'en apprend rien. Une clé publique malformée, un texte chiffré ou une clé de mauvaise taille, et une clé privée qui échoue à la vérification du hachage sont refusés avant tout calcul, et une clé privée ML-KEM, ML-DSA ou SLH-DSA importée fait l'objet d'un contrôle de cohérence, si bien qu'une clé dont les parties ne vont pas ensemble ne peut pas être chargée par erreur.

Delphi 7 à 13, sans changement

Aucun type entier 64 bits natif n'est supposé. sgcCrypto_Int64 et TsgcBigInt émulent l'arithmétique dont ont besoin les hachages, les courbes et les unités post-quantiques, si bien que la même source compile sur chaque version prise en charge.

Rien ne sort de ton processus

Chaque fonction s'exécute in-process sur les données que tu lui passes. Il n'y a aucun appel réseau, aucune télémétrie et aucun relais eSeGeCe nulle part dans la bibliothèque.

Inclus, ou en pack autonome

sgcCrypto est livré gratuitement avec sgcWebSockets Standard, Professional et Enterprise. Si tu ne possèdes que sgcWebSockets Core, il est aussi vendu comme pack à part, à partir de €149 pour un développeur. Toutes les licences incluent le code source complet, 1 an de mises à jour et une réduction de 50 % à 70 % sur le renouvellement : 50 % si tu renouvelles un pack, 60 % pour deux, 70 % pour trois ou plus.

sgcCrypto

€149

Pack autonome. Licences Single, Team et Site disponibles. Gratuit si tu possèdes déjà sgcWebSockets Standard, Professional ou Enterprise.

  • Les 43 unités sgcCrypto_*.pas
  • Runtime sgcWebSockets Core inclus
  • Delphi et C++ Builder, les six plateformes
  • Code source complet
  • 1 an de mises à jour

Déjà sur sgcWebSockets Standard, Professional ou Enterprise ? sgcCrypto est déjà dans ton installateur, aucune commande nécessaire.

Voir les tarifs et commander
3,000+Développeurs
20+Ans
761+Composants
30+Intégrations d'API
5Plateformes
Garantie satisfait ou remboursé de 30 joursPas satisfait ? Demandez un remboursement intégral dans les 30 jours suivant l'achat. Voir la politique de remboursement

La cryptographie sans le poids des composants

43 fonctions pures couvrant le chiffrement, le hachage, les signatures, la PKI et l'échange de clés post-quantique, plus un moteur TLS 1.3 et TLS 1.2 bâti dessus, prêtes partout où ton code Delphi ou C++ Builder tourne déjà. Code source complet, aucun relais, aucune DLL.

Autres produits d'eSeGeCe

Associe sgcCrypto à nos autres bibliothèques de composants Delphi et C++ Builder.

sgcWebSockets

Composants WebSocket, HTTP/2, MQTT, AMQP et WebRTC de niveau entreprise. Standard, Professional et Enterprise incluent tous sgcCrypto.

En savoir plus →

sgcSign

Signatures numériques de niveau entreprise. XAdES, PAdES, CAdES et ASiC avec 10 fournisseurs de clés et 21 profils de pays de l'UE.

En savoir plus →

sgcAuth

Composants client OAuth2 et client JWT, plus la connexion par passkey WebAuthn. Autonome, le runtime sgcWebSockets Core est inclus.

En savoir plus →

sgcQUIC

Composants client et serveur QUIC (RFC 9000) et HTTP/3 (RFC 9114) bâtis sur le moteur QUIC natif d'OpenSSL 3.5.

En savoir plus →

sgcAI

Composants IA, LLM et MCP. Un seul composant de chat atteint OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok et Mistral.

En savoir plus →

sgcMQ

Composants client natifs MQTT 3.1.1/5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka et STOMP, avec le runtime Core inclus.

En savoir plus →

sgcOpenAPI

Parser OpenAPI 3.0 et générateur de SDK. Transforme n'importe quelle spécification OpenAPI en client Delphi fortement typé en quelques secondes.

En savoir plus →