Ab sgcWebSockets Standard enthalten Auch eigenständig erhältlich

sgcCrypto — eine moderne Kryptographiebibliothek für Delphi & C++ Builder

43 reine Object-Pascal-Units, keine Komponenten, kein Design-Time-Footprint: TBytes rein, TBytes raus. AES-GCM und ChaCha20-Poly1305 für Verschlüsselung, SHA-3/BLAKE2/Argon2 für Hashing, Ed25519/X25519/RSA für Signaturen und Schlüsselaustausch, X.509-Zertifikatsparsing und -erstellung, sowie Post-Quanten-ML-KEM, ML-DSA und SLH-DSA, deren Schlüssel und Zertifikate in dieselben X.509-, PKCS#8- und PEM-Dateien wandern wie alles andere. Das Paket bringt außerdem eine TLS-1.3- und TLS-1.2-Engine mit, geschrieben in demselben Object Pascal, ausgewählt mit iohNativeTLS, mit X25519MLKEM768-Hybrid-Schlüsselaustausch standardmäßig aktiv. Jede Primitive ist direkt in der Unit implementiert, die du in deine uses-Klausel aufnimmst: keine externe DLL, keine OpenSSL-Anbindung, und derselbe Quellcode kompiliert unverändert von Delphi 7 bis RAD Studio 13. sgcCrypto ist bei sgcWebSockets Standard, Professional und Enterprise kostenlos dabei, und wird auch eigenständig verkauft (mit gebündelter sgcWebSockets-Core-Runtime) für Kunden, die nur Core besitzen.

Vollständiger Quellcode
Win32, Win64, Linux64, macOS, iOS & Android
Delphi 7 → 13, unverändert
Keine externen Abhängigkeiten
43 reine Funktionen sgcCrypto_*.pas Keine Komponenten. Eine Funktion aufrufen, Bytes zurückbekommen.
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 in zwei Minuten

Moderne Kryptografie für Delphi: AES-GCM, SHA-3, Ed25519, X.509 und Post-Quanten-Verfahren wie ML-KEM, ohne OpenSSL-DLLs im Gepäck.

43 Reine Funktions-Units sgcCrypto_*.pas, null Komponenten
6 Fähigkeitsfamilien Symmetrisch, Hashing, Signaturen, PKI, PQC, OTP
6 Zielplattformen Win32, Win64, Linux64, macOS, iOS, Android
3 Post-Quanten-FIPS-Standards ML-KEM (203), ML-DSA (204), SLH-DSA (205)
2 Wege, es zu besitzen In einer Edition enthalten, oder eigenständig

Drei Dinge, die du vorher wissen solltest

Was sgcCrypto ist, ob du es bereits besitzt, und wo es läuft. Alle drei Antworten sind kurz.

sgcCrypto besteht aus reinen Funktionen, keinen Komponenten

Jede der 43 Units exportiert einfache Funktionen und Prozeduren. Es gibt keine Tsgc*-Klasse, nichts wird per RegisterComponents registriert, und es gibt keine sgcCrypto_Reg.pas. Du rufst sgcAES_GCM_Encrypt(aKey, aIV, aPlain, aAAD, aTag) genauso auf, wie du jede RTL-Funktion aufrufen würdest, aus einem Formular, einem Dienst, einer Konsolenanwendung oder einem Thread.

Vollständiger Quellcode ist bei jeder Lizenz dabei, sodass sich die Primitiven in deinem eigenen Debugger durchsteppen lassen, statt in einer Binärdatei oder DLL zu verschwinden.

Edition-Überschneidung

Besitzt du bereits eine sgcWebSockets-Edition?

sgcCrypto ist in sgcWebSockets Standard, Professional und Enterprise sowie in All-Access ohne Aufpreis enthalten. Wenn du bereits eine Editionslizenz ab Standard besitzt, hast du bereits alle 43 Units, nichts weiter zu kaufen.

sgcCrypto existiert eigenständig für den umgekehrten Fall: Du besitzt nur sgcWebSockets Core, oder überhaupt keine sgcWebSockets-Lizenz, und möchtest die Krypto-Units ohne den Kauf einer vollständigen Edition.

Plattformumfang

sgcCrypto trägt keine Plattformsperre

Anders als die KI- oder Sprachpakete schränkt nichts in sgcVer.inc sgcCrypto auf Windows ein. Die Units sind gewöhnliche Object-Pascal-Arithmetik, kompilieren also aus demselben Quellcode für Win32, Win64, Linux64, macOS, iOS und Android.

Die eine plattformbewusste Unit, sgcCrypto_Random, wählt pro Ziel ein CSPRNG-Backend (BCryptGenRandom unter Windows, oder /dev/urandom anderswo) hinter demselben sgcRandomBytes-Aufruf, sodass dein Code nie nach Plattform verzweigt.

43 Units, sechs Fähigkeitsfamilien

Jede Unit ist kompiliertes Object Pascal, aufrufbar aus jedem Delphi-7-bis-13- oder C++-Builder-Projekt. Es gibt keine externe DLL, keine OpenSSL-Anbindung und keinen Codegenerator: Die Primitiven sind direkt in der Unit implementiert, die du in deine uses-Klausel aufnimmst.

Symmetrisch5 Units

AES, ChaCha20 und die AEAD-Konstruktionen darauf

sgcCrypto_AES deckt CBC, GCM und CTR ab; sgcCrypto_Modes ergänzt ECB, OFB, CFB, Ciphertext-Stealing CTS, AES-CCM sowie AES Key Wrap / Key Wrap with Padding (RFC 3394 / 5649); sgcCrypto_CMAC ist AES-CMAC und AES-GMAC. sgcCrypto_ChaCha implementiert ChaCha20, XChaCha20, Salsa20 und XSalsa20, und sgcCrypto_Poly1305 kombiniert Poly1305 damit zu den AEAD-Chiffren ChaCha20-Poly1305 und XChaCha20-Poly1305 aus RFC 8439. AES-CCM ist die AEAD-Chiffre, die Zigbee, Bluetooth und die TLS-CCM-Suiten namentlich vorschreiben, da sie nichts über die Blockchiffre selbst hinaus benötigt, und CBC sowie ECB akzeptieren beide das Padding-Schema deiner Wahl, PKCS#7, ANSI X9.23, ISO 7816-4 und den Rest, für den Tag, an dem du lesen musst, was ein anderes System geschrieben hat. sgcAES_GCM_Decrypt und die Poly1305-Verifizierer vergleichen den Authentifizierungs-Tag in konstanter Zeit und verweigern die Rückgabe von Klartext bei einem fehlgeschlagenen Vergleich.

Hashing & KDF11 Units

SHA-2, SHA-3, BLAKE2 und jede gängige KDF

sgcCrypto_SHA2 und sgcCrypto_Keccak decken SHA-1/2, SHA-3, SHAKE, cSHAKE und KMAC ab; sgcCrypto_Blake2b und sgcCrypto_Blake2s ergänzen BLAKE2. sgcCrypto_HMAC ist Keyed Message Authentication. Um ein Passwort in einen Schlüssel zu verwandeln: sgcCrypto_KDF (PBKDF2), sgcCrypto_HKDF, sgcCrypto_Scrypt und sgcCrypto_Argon2, das alle drei Argon2-Varianten implementiert, d, i und id, den Gewinner der Password Hashing Competition. sgcCrypto_SipHash liefert dir einen schnellen Keyed Hash für Hashtable-Schlüssel, und sgcCrypto_TLSH ist ein Fuzzy Hash mit einer Ähnlichkeits-Distanzfunktion, kein kryptographischer Digest, nützlich zur Erkennung von Near-Duplicates.

Signaturen & Schlüsselaustausch10 Units

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

sgcCrypto_Ed25519/Ed448 signieren und verifizieren; sgcCrypto_X25519/X448 übernehmen den passenden Diffie-Hellman-Austausch. sgcCrypto_ECCurves ergänzt ECDSA und ECDH über sieben Kurven, secp256k1, die drei Brainpool-Kurven und NIST P-256/P-384/P-521, mit deterministischen RFC-6979-Nonces und Signaturen in roher oder DER-Form, sowie BIP-340-Schnorr-Signierung obendrauf, mit den x-only-Public-Keys, die Taproot, Nostr und Lightning erwarten. sgcCrypto_EC ist das JOSE-orientierte Gegenstück: Signiere und verifiziere ein JWS direkt, ES256/384/512. sgcCrypto_RSA verifiziert PKCS#1-v1.5- und PSS-Signaturen direkt aus einem PEM-Schlüssel, und sgcCrypto_RSA_Keys geht weiter, mit Schlüsselerzeugung beliebiger Bitlänge, OAEP- und PKCS#1-v1.5-Verschlüsselung, sowie DER/PEM-Export sowohl in der PKCS#1- als auch der PKCS#8-Form BEGIN PRIVATE KEY. RSA- und EC-Schlüssel lassen sich ebenso leicht importieren wie exportieren, DER oder PEM, sodass ein einmal erzeugter Schlüssel gespeichert und wieder geladen werden kann, statt nur so lange zu leben wie der Prozess. sgcCrypto_ECIES rundet es mit hybrider Seal/Open-Verschlüsselung an einen X25519-Public-Key ab.

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

X.509-Zertifikate lesen, verifizieren und erzeugen

sgcCrypto_ASN1 liest DER und PEM und parst PKCS#1/SEC-1-Schlüssel; sgcCrypto_DER schreibt jeden Tag, den ein Zertifikat oder ein CSR braucht. sgcCrypto_X509 parst ein Zertifikat, verifiziert, dass es von einem gegebenen Aussteller signiert wurde, durchläuft und verifiziert eine Kette, verifiziert einen CSR, und parst eine CRL, um Widerruf zu prüfen. sgcCrypto_X509_Gen erzeugt ein selbstsigniertes Zertifikat oder einen PKCS#10-CSR von Grund auf, und eine CA stellt mit sgcX509_CreateSigned oder sgcX509_CreateSignedFromCSR aus: vollständiger Subject- und Issuer-Distinguished-Name, Gültigkeitsfenster, CA-Flag mit Pfadlängenbeschränkung, Key-Usage-Flags, Extended-Key-Usage-OIDs und Subject Alternative Names, einschließlich IP-Adress-SANs, die jetzt IPv6 in jeder Textform nach RFC 4291 annehmen, und URI-SANs für SPIFFE-artige Dienstidentitäten.

Signieren ist nicht mehr auf RSA und EC beschränkt. sgcX509_MLDSAKey und sgcX509_SLHDSAKey verpacken einen Post-Quanten-Schlüssel für sgcX509_CreateSelfSignedEx und sgcX509_CreateCSREx, sodass ein Zertifikat oder ein CSR mit ML-DSA oder SLH-DSA signiert werden kann. Eine CA kann außerdem einen ML-KEM-Public-Key zertifizieren (RFC 9935), der nicht signieren kann, sodass der Besitz auf anderem Weg nachgewiesen werden muss. Auf der Leseseite hat TsgcX509PublicKeyType x509pkMLDSA, x509pkSLHDSA und x509pkMLKEM dazubekommen, und sgcX509_VerifyChain erzwingt jetzt die basicConstraints-Pfadlänge und die nameConstraints-Erweiterung über dNSName, iPAddress, rfc822Name, uniformResourceIdentifier und directoryName, auf der Erzeugungsseite geschrieben aus PermittedDNSNames, ExcludedDNSNames, PermittedIPRanges und ExcludedIPRanges. Ein EC-Zertifikat kommt weiterhin etwa ein Drittel so groß heraus wie ein RSA-Zertifikat und verifiziert weit schneller, weshalb neue Deployments zu einem greifen.

sgcCrypto_X509 sgcCrypto_X509_Gen sgcCrypto_ASN1 RFC 5280 · RFC 2986 · RFC 9881 · RFC 9909 · RFC 9935
Post-Quanten6 Units

ML-KEM, ML-DSA und SLH-DSA, plus ein Hybrid-Combiner

sgcCrypto_MLKEM ist FIPS-203-Schlüsselkapselung, drei Parametersätze (ML-KEM-512/768/1024), mit impliziter Zurückweisung bei einem fehlerhaften Chiffretext. sgcCrypto_MLDSA ist FIPS-204-Signierung, ML-DSA-44/65/87. sgcCrypto_SLHDSA ist FIPS 205, alle sechs SHAKE-Parametersätze: 128s, 128f, 192s, 192f, 256s, 256f. Weil ML-KEM allein alles auf eine Gitter-Annahme setzt, die jünger ist als elliptische Kurven, kombiniert sgcCrypto_MLKEM_Hybrid ein X25519-Geheimnis und ein ML-KEM-Geheimnis zu einem gemeinsamen Schlüssel, sodass das Ergebnis nie schwächer ist als die klassische Hälfte, das Migrationsmuster, auf das sich die Branche gerade einigt.

Dieselbe Unit implementiert X-Wing (draft-connolly-cfrg-xwing-kem-10), X25519 mit ML-KEM-768 als ein einziges KEM: ein Public Key von 1216 Byte, ein Private Key von 32 Byte (der Seed), ein Chiffretext von 1120 Byte und ein Shared Secret von 32 Byte, über sgcXWing_GenerateKeyPair, sgcXWing_Encapsulate und sgcXWing_Decapsulate. Sie baut außerdem die TLS-1.3-Hybrid-Key-Shares aus RFC 10024 für X25519MLKEM768, SecP256r1MLKEM768 und SecP384r1MLKEM1024 (IANA-Codepoints 0x11EC, 0x11EB und 0x11ED). Diese drei sind keine eigenständigen KEMs, sie bauen nur einen TLS-Key-Share.

Alle drei Algorithmen lesen und schreiben Schlüssel jetzt als X.509 SubjectPublicKeyInfo, PKCS#8 OneAsymmetricKey und PEM, sodass ein Post-Quanten-Schlüssel in denselben Dateien liegt wie ein RSA- oder EC-Schlüssel. ML-DSA- und ML-KEM-Private-Keys haben drei Formen, ausgewählt mit TsgcPQCPrivateKeyFormat: pqkfSeed schreibt nur den Seed (32 Byte bei ML-DSA, den 64 Byte langen d||z-Seed bei ML-KEM), pqkfExpanded schreibt den expandierten Schlüssel, pqkfBoth trägt beides. SLH-DSA hat eine einzige Private-Key-Form. sgcMLDSA_GenerateKeyPairAndSeed und sgcMLKEM_GenerateKeyPairAndSeed geben den Seed zusammen mit dem Schlüsselpaar zurück, sodass sich eine Datei in Seed-Form direkt nach der Erzeugung schreiben lässt.

sgcCrypto_MLKEM sgcCrypto_MLDSA sgcCrypto_SLHDSA sgcCrypto_MLKEM_Hybrid FIPS 203 · FIPS 204 · FIPS 205 · RFC 10024
OTP & Sonstiges6 Units

Einmalpasswörter, Kodierung und verschlüsselte ZIP-Einträge

sgcCrypto_OTP erzeugt und verifiziert HOTP- und TOTP-Codes, dieselben sechsstelligen Codes, die eine Authenticator-App anzeigt, mit einem konstantzeitigen Verifikationsfenster, das Uhrabweichung ausgleicht. sgcCrypto_Encoding hält die Hilfsfunktionen, die sich der Rest der Bibliothek teilt: konstantzeitiger Vergleich, sicheres Nullsetzen von Puffern, Hex, Base64url und Base32. sgcCrypto_Zip_AE2 implementiert die WinZip-AES-Verschlüsselung, AE-1 und AE-2, zum Verschlüsseln einzelner ZIP-Einträge. sgcCrypto_Random ist der plattformübergreifende CSPRNG hinter jedem Schlüssel und Nonce, der anderswo in der Bibliothek erzeugt wird, und sgcCrypto_Legacy hält MD4/MD5/HMAC-MD5/DES-ECB für die Interoperabilität mit älteren Formaten verfügbar, nicht für neue Designs.

Eine TLS-1.3- und TLS-1.2-Engine in demselben Object Pascal

Das Paket bringt außerdem eine TLS-1.3- und TLS-1.2-Implementierung mit, die auf den sgcCrypto-Primitiven aufbaut. Sie liegt in den sgcSSL_NativeTLS*-Units statt in sgcCrypto_*, gehört also nicht zu den 43, und sie wird überall dort ausgeliefert, wo auch sgcCrypto ausgeliefert wird. Wähle sie mit einer einzigen Eigenschaft an jedem sgcWebSockets-Client oder -Server aus, und es gibt auf keiner Plattform etwas auszuliefern.

// 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;
Post-Quanten-Schlüsselaustausch ab Werk

Die Standardliste der Gruppen beginnt mit X25519MLKEM768, dem RFC-10024-Hybrid aus X25519 und ML-KEM-768, sodass ein Handshake mit einem Peer, der ihn unterstützt, ohne jede Konfiguration bereits Post-Quanten ist. SecP256r1MLKEM768 und SecP384r1MLKEM1024 stehen auf derselben Liste zur Verfügung.

Nichts auszuliefern, auf keinem Ziel

Kein libssl, kein libcrypto, kein SChannel und kein Plattform-TLS-Stack, nur dasselbe Object Pascal unter Win32, Win64, Linux64, macOS, iOS und Android. Setze TLSOptions.IOHandler := iohNativeTLS an einem Client oder SSLOptions.IOHandler := iohNativeTLS an einem Server, die IOCP- und EPOLL-Server-Engines eingeschlossen.

Die Roots, denen die Maschine bereits vertraut

Setze NativeTLS_Options.UseSystemRoots auf True, und die Engine fügt die vertrauenswürdigen Roots des Betriebssystems zu RootCertFile hinzu: den ROOT-Speicher unter Windows und auf jeder anderen Plattform das erste CA-Bundle, das sich an den Standardorten findet. Sie liest nie den macOS- oder iOS-Schlüsselbund oder den Android-Speicher. Standardmäßig ist es ausgeschaltet, sodass die Anker genau das bleiben, was RootCertFile sagt. Auf einem Server gilt dieselbe Eigenschaft für die Clientzertifikate, die er verifiziert.

Kenne die Grenzen, bevor du wechselst

Die Engine spricht ausschließlich TLS 1.3 und TLS 1.2, ohne TLS 1.1, TLS 1.0 oder SSL, und die hybriden Post-Quanten-Gruppen existieren ausschließlich in TLS 1.3, sodass eine TLS-1.2-Verbindung X25519, secp256r1 oder secp384r1 verwendet. Es gibt keine Session-Resumption und kein PSK, kein 0-RTT und kein QUIC. Widerrufsprüfung und Zertifikatsrichtlinien werden nicht geprüft, und das Komponentenereignis OnSSLVerifyPeer steht für sie nicht zur Verfügung, die Engine hat ihre eigenen Verifikations-Hooks. Bleib bei OpenSSL oder einem Plattform-Backend, wenn du etwas davon brauchst.

Keine Komponente, kein Objektinspektor

Füge eine Unit zu uses hinzu und rufe eine Funktion auf. Jeder Aufruf unten kommt aus einer anderen der 43 Units, quer über symmetrische Verschlüsselung, Hashing, Signaturen und Post-Quanten.

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);
Konstante Zeit, wo es zählt

Tag-Prüfungen, HOTP/TOTP-Verifizierung und sgcConstantTimeEquals vergleichen in konstanter Zeit, und dasselbe gilt für die Arbeit am Geheimnis. AES läuft auf einem Bitsliced-Kern, der den Speicher nie mit einem geheimen Byte indiziert und nie danach verzweigt, GHASH multipliziert unter einer Maske, und private RSA-Operationen werden geblendet und gegen den öffentlichen Exponenten geprüft, bevor irgendetwas zurückgegeben wird. ECDSA-Signierung, ECDH und die EC-Schlüsselerzeugung verwenden eine Skalarmultiplikation in konstanter Zeit, und die Ed25519-Signierung liest den Skalar in festen Fenstern mit einer vollständigen Additionsformel.

Implizite Zurückweisung, und Eingaben werden zuerst geprüft

Ein Chiffretext der richtigen Länge, der sich nicht entschlüsseln lässt, liefert ein pseudozufälliges Geheimnis statt eines Fehlers, implizite Zurückweisung nach FIPS 203, sodass ein Angreifer daraus nichts lernt. Ein fehlerhafter öffentlicher Schlüssel, ein Chiffretext oder Schlüssel falscher Größe und ein privater Schlüssel, der die Hash-Prüfung nicht besteht, werden vor jeder Berechnung abgelehnt, und ein importierter privater ML-KEM-, ML-DSA- oder SLH-DSA-Schlüssel wird auf Konsistenz geprüft, sodass ein Schlüssel, dessen Teile nicht zusammengehören, nicht versehentlich geladen werden kann.

Delphi 7 bis 13, unverändert

Es wird kein nativer 64-Bit-Integer-Typ vorausgesetzt. sgcCrypto_Int64 und TsgcBigInt emulieren die Arithmetik, die die Hashes, Kurven und Post-Quanten-Units brauchen, sodass derselbe Quellcode auf jeder unterstützten Version kompiliert.

Nichts verlässt deinen Prozess

Jede Funktion läuft in-process mit Daten, die du übergibst. Es gibt keinen Netzwerkaufruf, keine Telemetrie und kein eSeGeCe-Relay irgendwo in der Bibliothek.

Enthalten, oder als eigenständiges Paket

sgcCrypto ist bei sgcWebSockets Standard, Professional und Enterprise kostenlos dabei. Wenn du nur sgcWebSockets Core besitzt, wird es auch als eigenes Paket verkauft, ab €149 für einen Entwickler. Alle Lizenzen enthalten vollständigen Quellcode, 1 Jahr Updates und 50% bis 70% Verlängerungsrabatt: 50% bei Verlängerung eines Pakets, 60% bei zweien, 70% bei drei oder mehr.

sgcCrypto

€149

Eigenständiges Paket. Single-, Team- und Site-Lizenzen verfügbar. Kostenlos, wenn du bereits sgcWebSockets Standard, Professional oder Enterprise besitzt.

  • Alle 43 sgcCrypto_*.pas-Units
  • sgcWebSockets-Core-Runtime enthalten
  • Delphi & C++ Builder, alle sechs Plattformen
  • Vollständiger Quellcode
  • 1 Jahr Updates

Bereits auf sgcWebSockets Standard, Professional oder Enterprise? sgcCrypto ist bereits in deinem Installer, keine Bestellung nötig.

Preise ansehen & bestellen
3,000+Entwickler
20+Jahre
761+Komponenten
30+API-Integrationen
5Plattformen
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordere innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen

Kryptographie ohne Komponenten-Overhead

43 reine Funktionen für Verschlüsselung, Hashing, Signaturen, PKI und Post-Quanten-Schlüsselaustausch, plus eine darauf aufbauende TLS-1.3- und TLS-1.2-Engine, einsatzbereit überall dort, wo dein Delphi- oder C++-Builder-Code bereits läuft. Vollständiger Quellcode, kein Relay, keine DLL.

Weitere Produkte von eSeGeCe

Kombiniere sgcCrypto mit unseren anderen Komponentenbibliotheken für Delphi und C++ Builder.

sgcWebSockets

Enterprise-WebSocket-, HTTP/2-, MQTT-, AMQP- und WebRTC-Komponenten. Standard, Professional und Enterprise enthalten alle sgcCrypto.

Mehr erfahren →

sgcSign

Digitale Signaturen für Unternehmen. XAdES, PAdES, CAdES und ASiC mit 10 Schlüsselanbietern und 21 EU-Länderprofilen.

Mehr erfahren →

sgcAuth

OAuth2-Client- und JWT-Client-Komponenten, plus WebAuthn-Passkey-Anmeldung. Eigenständig, die sgcWebSockets Core Runtime ist enthalten.

Mehr erfahren →

sgcQUIC

QUIC- (RFC 9000) und HTTP/3-Client- und -Serverkomponenten (RFC 9114) auf der nativen OpenSSL-3.5-QUIC-Engine.

Mehr erfahren →

sgcAI

KI-, LLM- und MCP-Komponenten. Eine Chat-Komponente erreicht OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok und Mistral.

Mehr erfahren →

sgcMQ

Native MQTT-3.1.1/5.0-, AMQP-0.9.1-, AMQP-1.0-, Apache-Kafka- und STOMP-Clientkomponenten, mit gebündelter Core Runtime.

Mehr erfahren →

sgcOpenAPI

OpenAPI-3.0-Parser und SDK-Generator. Verwandle jede OpenAPI-Spezifikation in Sekunden in einen stark typisierten Delphi-Client.

Mehr erfahren →