add demos

CryptoLib.Examples/Delphi.Examples/CryptoLib.Examples.dpr

@@ -0,0 +1,514 @@
+program CryptoLib.Examples;
+
+{$STRONGLINKTYPES ON}
+
+{$APPTYPE CONSOLE}
+{$R *.res}
+
+uses
+  SysUtils,
+  ClpLogger in '..\src\ClpLogger.pas',
+  ClpConsoleLogger in '..\src\ClpConsoleLogger.pas',
+  ClpExampleBase in '..\src\ClpExampleBase.pas',
+  ClpExampleExplorer in '..\src\ClpExampleExplorer.pas',
+  ClpDigestExample in '..\src\Examples\ClpDigestExample.pas',
+  ClpRsaExample in '..\src\Examples\ClpRsaExample.pas',
+  ClpEcExample in '..\src\Examples\ClpEcExample.pas',
+  ClpCertificateExample in '..\src\Examples\ClpCertificateExample.pas',
+  ClpCipherExample in '..\src\Examples\ClpCipherExample.pas',
+  ClpAesEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpAesEngine.pas',
+  ClpAesLightEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpAesLightEngine.pas',
+  ClpAgreementUtilities in '..\..\CryptoLib\src\Crypto\Agreements\ClpAgreementUtilities.pas',
+  ClpArgon2ParametersGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpArgon2ParametersGenerator.pas',
+  ClpArrayUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpArrayUtilities.pas',
+  ClpAsn1DigestFactory in '..\..\CryptoLib\src\Crypto\Operators\ClpAsn1DigestFactory.pas',
+  ClpAsn1Dumper in '..\..\CryptoLib\src\Asn1\ClpAsn1Dumper.pas',
+  ClpAsn1Comparers in '..\..\CryptoLib\src\Asn1\ClpAsn1Comparers.pas',
+  ClpAsn1Objects in '..\..\CryptoLib\src\Asn1\ClpAsn1Objects.pas',
+  ClpAsn1SignatureFactory in '..\..\CryptoLib\src\Crypto\Operators\ClpAsn1SignatureFactory.pas',
+  ClpAsn1Streams in '..\..\CryptoLib\src\Asn1\ClpAsn1Streams.pas',
+  ClpAsn1Utilities in '..\..\CryptoLib\src\Asn1\ClpAsn1Utilities.pas',
+  ClpAsn1VerifierFactory in '..\..\CryptoLib\src\Crypto\Operators\ClpAsn1VerifierFactory.pas',
+  ClpAsn1VerifierFactoryProvider in '..\..\CryptoLib\src\Crypto\Operators\ClpAsn1VerifierFactoryProvider.pas',
+  ClpAsymmetricCipherKeyPair in '..\..\CryptoLib\src\Crypto\ClpAsymmetricCipherKeyPair.pas',
+  ClpAsymmetricKeyParameter in '..\..\CryptoLib\src\Crypto\Parameters\ClpAsymmetricKeyParameter.pas',
+  ClpBaseKdfBytesGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpBaseKdfBytesGenerator.pas',
+  ClpBigInteger in '..\..\CryptoLib\src\Math\ClpBigInteger.pas',
+  ClpBigIntegerUtilities in '..\..\CryptoLib\src\Math\ClpBigIntegerUtilities.pas',
+  ClpPrimes in '..\..\CryptoLib\src\Math\ClpPrimes.pas',
+  ClpBitConverter in '..\..\CryptoLib\src\Misc\ClpBitConverter.pas',
+  ClpCbcBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpCbcBlockCipher.pas',
+  ClpCfbBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpCfbBlockCipher.pas',
+  ClpCtsBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpCtsBlockCipher.pas',
+  ClpOfbBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpOfbBlockCipher.pas',
+  ClpSicBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpSicBlockCipher.pas',
+  ClpBlowfishEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpBlowfishEngine.pas',
+  ClpBsiObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Bsi\ClpBsiObjectIdentifiers.pas',
+  ClpBufferedAsymmetricBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpBufferedAsymmetricBlockCipher.pas',
+  ClpBufferedBlockCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpBufferedBlockCipher.pas',
+  ClpBufferedCipherBase in '..\..\CryptoLib\src\Crypto\Ciphers\ClpBufferedCipherBase.pas',
+  ClpBufferedStreamCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpBufferedStreamCipher.pas',
+  ClpBufferedIesCipher in '..\..\CryptoLib\src\Crypto\Ciphers\ClpBufferedIesCipher.pas',
+  ClpChaChaEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpChaChaEngine.pas',
+  ClpCheck in '..\..\CryptoLib\src\Crypto\ClpCheck.pas',
+  ClpCodec in '..\..\CryptoLib\src\Math\EC\Rfc8032\ClpCodec.pas',
+  ClpCipherKeyGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpCipherKeyGenerator.pas',
+  ClpCipherUtilities in '..\..\CryptoLib\src\Crypto\Ciphers\ClpCipherUtilities.pas',
+  ClpCollectionUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpCollectionUtilities.pas',
+  ClpConverters in '..\..\CryptoLib\src\Misc\ClpConverters.pas',
+  ClpCryptLibObjectIdentifiers in '..\..\CryptoLib\src\Asn1\CryptLib\ClpCryptLibObjectIdentifiers.pas',
+  ClpCryptoApiRandomGenerator in '..\..\CryptoLib\src\Rngs\ClpCryptoApiRandomGenerator.pas',
+  ClpCryptoLibComparers in '..\..\CryptoLib\src\Misc\ClpCryptoLibComparers.pas',
+  ClpCryptoLibTypes in '..\..\CryptoLib\src\Misc\ClpCryptoLibTypes.pas',
+  ClpCryptoProObjectIdentifiers in '..\..\CryptoLib\src\Asn1\CryptoPro\ClpCryptoProObjectIdentifiers.pas',
+  ClpDateTimeUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpDateTimeUtilities.pas',
+  ClpDefaultDigestCalculator in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultDigestCalculator.pas',
+  ClpDefaultDigestResult in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultDigestResult.pas',
+  ClpDefaultSignatureCalculator in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultSignatureCalculator.pas',
+  ClpDefaultSignatureResult in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultSignatureResult.pas',
+  ClpDefaultVerifierCalculator in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultVerifierCalculator.pas',
+  ClpDefaultVerifierResult in '..\..\CryptoLib\src\Crypto\Operators\ClpDefaultVerifierResult.pas',
+  ClpDHAgreement in '..\..\CryptoLib\src\Crypto\Agreements\ClpDHAgreement.pas',
+  ClpDHBasicAgreement in '..\..\CryptoLib\src\Crypto\Agreements\ClpDHBasicAgreement.pas',
+  ClpDHGenerators in '..\..\CryptoLib\src\Crypto\Generators\ClpDHGenerators.pas',
+  ClpDHKeyGeneratorHelper in '..\..\CryptoLib\src\Crypto\Generators\ClpDHKeyGeneratorHelper.pas',
+  ClpDHParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpDHParameters.pas',
+  ClpDHParametersHelper in '..\..\CryptoLib\src\Crypto\Generators\ClpDHParametersHelper.pas',
+  ClpDigest in '..\..\CryptoLib\src\Crypto\Digests\ClpDigest.pas',
+  ClpDigestRandomGenerator in '..\..\CryptoLib\src\Rngs\ClpDigestRandomGenerator.pas',
+  ClpDigestSink in '..\..\CryptoLib\src\Crypto\IO\ClpDigestSink.pas',
+  ClpDigestUtilities in '..\..\CryptoLib\src\Crypto\Digests\ClpDigestUtilities.pas',
+  ClpDsaDigestSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpDsaDigestSigner.pas',
+  ClpDsaGenerators in '..\..\CryptoLib\src\Crypto\Generators\ClpDsaGenerators.pas',
+  ClpDsaParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpDsaParameters.pas',
+  ClpDsaSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpDsaSigner.pas',
+  ClpEacObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Eac\ClpEacObjectIdentifiers.pas',
+  ClpECAlgorithms in '..\..\CryptoLib\src\Math\EC\ClpECAlgorithms.pas',
+  ClpECCurve in '..\..\CryptoLib\src\Math\EC\ClpECCurve.pas',
+  ClpECCurveConstants in '..\..\CryptoLib\src\Math\EC\ClpECCurveConstants.pas',
+  ClpECDHBasicAgreement in '..\..\CryptoLib\src\Crypto\Agreements\ClpECDHBasicAgreement.pas',
+  ClpECDHCBasicAgreement in '..\..\CryptoLib\src\Crypto\Agreements\ClpECDHCBasicAgreement.pas',
+  ClpECParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpECParameters.pas',
+  ClpECDsaSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpECDsaSigner.pas',
+  ClpECGost3410NamedCurves in '..\..\CryptoLib\src\Asn1\CryptoPro\ClpECGost3410NamedCurves.pas',
+  ClpECIESPublicKeyParser in '..\..\CryptoLib\src\Crypto\Parsers\ClpECIESPublicKeyParser.pas',
+  ClpECGenerators in '..\..\CryptoLib\src\Crypto\Generators\ClpECGenerators.pas',
+  ClpECNamedCurveTable in '..\..\CryptoLib\src\Asn1\X9\ClpECNamedCurveTable.pas',
+  ClpECNRSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpECNRSigner.pas',
+  ClpEd25519 in '..\..\CryptoLib\src\Math\EC\Rfc8032\ClpEd25519.pas',
+  ClpEd25519CtxSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpEd25519CtxSigner.pas',
+  ClpEd25519Parameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpEd25519Parameters.pas',
+  ClpEd25519Generators in '..\..\CryptoLib\src\Crypto\Generators\ClpEd25519Generators.pas',
+  ClpEd25519PhSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpEd25519PhSigner.pas',
+  ClpEd25519Signer in '..\..\CryptoLib\src\Crypto\Signers\ClpEd25519Signer.pas',
+  ClpEdECObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Edec\ClpEdECObjectIdentifiers.pas',
+  ClpEncoders in '..\..\CryptoLib\src\Encoders\ClpEncoders.pas',
+  ClpEndoPreCompInfo in '..\..\CryptoLib\src\Math\EC\Endo\ClpEndoPreCompInfo.pas',
+  ClpEnumUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpEnumUtilities.pas',
+  ClpEphemeralKeyPair in '..\..\CryptoLib\src\Crypto\ClpEphemeralKeyPair.pas',
+  ClpEphemeralKeyPairGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpEphemeralKeyPairGenerator.pas',
+  ClpFiniteFields in '..\..\CryptoLib\src\Math\Field\ClpFiniteFields.pas',
+  ClpFixedPointPreCompInfo in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpFixedPointPreCompInfo.pas',
+  ClpFixedPointUtilities in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpFixedPointUtilities.pas',
+  ClpGeneratorUtilities in '..\..\CryptoLib\src\Crypto\Generators\ClpGeneratorUtilities.pas',
+  ClpGenericPolynomialExtensionField in '..\..\CryptoLib\src\Math\Field\ClpGenericPolynomialExtensionField.pas',
+  ClpGenericSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpGenericSigner.pas',
+  ClpGF2Polynomial in '..\..\CryptoLib\src\Math\Field\ClpGF2Polynomial.pas',
+  ClpGlvTypeBEndomorphism in '..\..\CryptoLib\src\Math\EC\Endo\ClpGlvTypeBEndomorphism.pas',
+  ClpGlvTypeBParameters in '..\..\CryptoLib\src\Math\EC\Endo\ClpGlvTypeBParameters.pas',
+  ClpHkdfBytesGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpHkdfBytesGenerator.pas',
+  ClpHkdfParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpHkdfParameters.pas',
+  ClpHMac in '..\..\CryptoLib\src\Crypto\Macs\ClpHMac.pas',
+  ClpHMacDsaKCalculator in '..\..\CryptoLib\src\Crypto\Signers\SignerCalculators\ClpHMacDsaKCalculator.pas',
+  ClpIAesEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIAesEngine.pas',
+  ClpIAesLightEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIAesLightEngine.pas',
+  ClpIanaObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Iana\ClpIanaObjectIdentifiers.pas',
+  ClpIArgon2ParametersGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIArgon2ParametersGenerator.pas',
+  ClpIAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIAsn1Objects.pas',
+  ClpIAsymmetricBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIAsymmetricBlockCipher.pas',
+  ClpIAsymmetricCipherKeyPair in '..\..\CryptoLib\src\Interfaces\Crypto\ClpIAsymmetricCipherKeyPair.pas',
+  ClpIAsymmetricCipherKeyPairGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIAsymmetricCipherKeyPairGenerator.pas',
+  ClpIAsymmetricKeyParameter in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIAsymmetricKeyParameter.pas',
+  ClpIBaseKdfBytesGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIBaseKdfBytesGenerator.pas',
+  ClpIBasicAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIBasicAgreement.pas',
+  ClpIBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBlockCipher.pas',
+  ClpICbcBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpICbcBlockCipher.pas',
+  ClpICfbBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpICfbBlockCipher.pas',
+  ClpICtsBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpICtsBlockCipher.pas',
+  ClpIOfbBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIOfbBlockCipher.pas',
+  ClpISicBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpISicBlockCipher.pas',
+  ClpIBlockCipherPadding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIBlockCipherPadding.pas',
+  ClpIBlockResult in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIBlockResult.pas',
+  ClpIBlowfishEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIBlowfishEngine.pas',
+  ClpIBufferedAsymmetricBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBufferedAsymmetricBlockCipher.pas',
+  ClpIBufferedBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBufferedBlockCipher.pas',
+  ClpIBufferedCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBufferedCipher.pas',
+  ClpIBufferedCipherBase in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBufferedCipherBase.pas',
+  ClpIBufferedStreamCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIBufferedStreamCipher.pas',
+  ClpIChaChaEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIChaChaEngine.pas',
+  ClpICipherKeyGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpICipherKeyGenerator.pas',
+  ClpICipherParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpICipherParameters.pas',
+  ClpICryptoApiRandomGenerator in '..\..\CryptoLib\src\Interfaces\Rngs\ClpICryptoApiRandomGenerator.pas',
+  ClpIDerivationFunction in '..\..\CryptoLib\src\Interfaces\Crypto\ClpIDerivationFunction.pas',
+  ClpIDerivationParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIDerivationParameters.pas',
+  ClpIDHAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIDHAgreement.pas',
+  ClpIDHBasicAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIDHBasicAgreement.pas',
+  ClpIDHGenerators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIDHGenerators.pas',
+  ClpIDHParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIDHParameters.pas',
+  ClpIDigest in '..\..\CryptoLib\src\Interfaces\Crypto\Digests\ClpIDigest.pas',
+  ClpIDigestFactory in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIDigestFactory.pas',
+  ClpIDigestRandomGenerator in '..\..\CryptoLib\src\Interfaces\Rngs\ClpIDigestRandomGenerator.pas',
+  ClpIDsa in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIDsa.pas',
+  ClpIDsaDigestSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIDsaDigestSigner.pas',
+  ClpIDsaKCalculator in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIDsaKCalculator.pas',
+  ClpIDsaGenerators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIDsaGenerators.pas',
+  ClpIDsaParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIDsaParameters.pas',
+  ClpIDsaSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIDsaSigner.pas',
+  ClpIECCommon in '..\..\CryptoLib\src\Interfaces\Math\EC\ClpIECCommon.pas',
+  ClpIECFieldElement in '..\..\CryptoLib\src\Interfaces\Math\EC\ClpIECFieldElement.pas',
+  ClpIECDHBasicAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIECDHBasicAgreement.pas',
+  ClpIECDHCBasicAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIECDHCBasicAgreement.pas',
+  ClpIECParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIECParameters.pas',
+  ClpIECDsaSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIECDsaSigner.pas',
+  ClpIECIESPublicKeyParser in '..\..\CryptoLib\src\Interfaces\Crypto\Parsers\ClpIECIESPublicKeyParser.pas',
+  ClpIECGenerators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIECGenerators.pas',
+  ClpIECNRSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIECNRSigner.pas',
+  ClpIEd25519CtxSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIEd25519CtxSigner.pas',
+  ClpIEd25519Parameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIEd25519Parameters.pas',
+  ClpIEd25519Generators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIEd25519Generators.pas',
+  ClpIEd25519PhSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIEd25519PhSigner.pas',
+  ClpIEd25519Signer in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIEd25519Signer.pas',
+  ClpIEndoPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Endo\ClpIEndoPreCompInfo.pas',
+  ClpIEphemeralKeyPair in '..\..\CryptoLib\src\Interfaces\Crypto\ClpIEphemeralKeyPair.pas',
+  ClpIEphemeralKeyPairGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIEphemeralKeyPairGenerator.pas',
+  ClpIesEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpIesEngine.pas',
+  ClpIesParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpIesParameters.pas',
+  ClpIetfUtilities in '..\..\CryptoLib\src\Asn1\X500\Style\ClpIetfUtilities.pas',
+  ClpIExtensionField in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIExtensionField.pas',
+  ClpIFiniteField in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIFiniteField.pas',
+  ClpIFixedPointPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIFixedPointPreCompInfo.pas',
+  ClpIGenericPolynomialExtensionField in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIGenericPolynomialExtensionField.pas',
+  ClpIGenericSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIGenericSigner.pas',
+  ClpIGF2Polynomial in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIGF2Polynomial.pas',
+  ClpIGlvTypeBEndomorphism in '..\..\CryptoLib\src\Interfaces\Math\EC\Endo\ClpIGlvTypeBEndomorphism.pas',
+  ClpIGlvTypeBParameters in '..\..\CryptoLib\src\Interfaces\Math\EC\Endo\ClpIGlvTypeBParameters.pas',
+  ClpIHkdfBytesGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIHkdfBytesGenerator.pas',
+  ClpIHkdfParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIHkdfParameters.pas',
+  ClpIHMac in '..\..\CryptoLib\src\Interfaces\Crypto\Macs\ClpIHMac.pas',
+  ClpIHMacDsaKCalculator in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\SignerCalculators\ClpIHMacDsaKCalculator.pas',
+  ClpIIesEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIIesEngine.pas',
+  ClpIIesParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIIesParameters.pas',
+  ClpIIso18033KdfParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIIso18033KdfParameters.pas',
+  ClpIISO9796d1Encoding in '..\..\CryptoLib\src\Interfaces\Crypto\Encodings\ClpIISO9796d1Encoding.pas',
+  ClpIKdf1BytesGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIKdf1BytesGenerator.pas',
+  ClpIKdf2BytesGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIKdf2BytesGenerator.pas',
+  ClpIKdfParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIKdfParameters.pas',
+  ClpIKeyEncoder in '..\..\CryptoLib\src\Interfaces\Crypto\ClpIKeyEncoder.pas',
+  ClpIKeyGenerationParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIKeyGenerationParameters.pas',
+  ClpIKeyParameter in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIKeyParameter.pas',
+  ClpIKeyParser in '..\..\CryptoLib\src\Interfaces\ClpIKeyParser.pas',
+  ClpIKMac in '..\..\CryptoLib\src\Interfaces\Crypto\Macs\ClpIKMac.pas',
+  ClpIMac in '..\..\CryptoLib\src\Interfaces\Crypto\Macs\ClpIMac.pas',
+  ClpIMacFactory in '..\..\CryptoLib\src\Interfaces\Crypto\ClpIMacFactory.pas',
+  ClpIOaepEncoding in '..\..\CryptoLib\src\Interfaces\Crypto\Encodings\ClpIOaepEncoding.pas',
+  ClpIOidTokenizer in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIOidTokenizer.pas',
+  ClpIPaddedBufferedBlockCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIPaddedBufferedBlockCipher.pas',
+  ClpIISO10126d2Padding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIISO10126d2Padding.pas',
+  ClpIISO7816d4Padding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIISO7816d4Padding.pas',
+  ClpIPkcs7Padding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIPkcs7Padding.pas',
+  ClpITBCPadding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpITBCPadding.pas',
+  ClpIX923Padding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIX923Padding.pas',
+  ClpIZeroBytePadding in '..\..\CryptoLib\src\Interfaces\Crypto\Paddings\ClpIZeroBytePadding.pas',
+  ClpIPAddressUtilities in '..\..\CryptoLib\src\Net\ClpIPAddressUtilities.pas',
+  ClpIParametersWithIV in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIParametersWithIV.pas',
+  ClpIParametersWithRandom in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIParametersWithRandom.pas',
+  ClpIPascalCoinECIESKdfBytesGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIPascalCoinECIESKdfBytesGenerator.pas',
+  ClpIPascalCoinIesEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIPascalCoinIesEngine.pas',
+  ClpIPbeParametersGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIPbeParametersGenerator.pas',
+  ClpIPemObjects in '..\..\CryptoLib\src\Interfaces\Pem\ClpIPemObjects.pas',
+  ClpIPkcs1Encoding in '..\..\CryptoLib\src\Interfaces\Crypto\Encodings\ClpIPkcs1Encoding.pas',
+  ClpIPkcs5S2ParametersGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIPkcs5S2ParametersGenerator.pas',
+  ClpIPkcsAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\Pkcs\ClpIPkcsAsn1Objects.pas',
+  ClpIPolynomial in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIPolynomial.pas',
+  ClpIPolynomialExtensionField in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIPolynomialExtensionField.pas',
+  ClpIPreCompCallback in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIPreCompCallback.pas',
+  ClpIPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIPreCompInfo.pas',
+  ClpIPrehash in '..\..\CryptoLib\src\Interfaces\Crypto\Digests\ClpIPrehash.pas',
+  ClpIPrimeField in '..\..\CryptoLib\src\Interfaces\Math\Field\ClpIPrimeField.pas',
+  ClpIPssSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIPssSigner.pas',
+  ClpIRandom in '..\..\CryptoLib\src\Interfaces\Crypto\Randoms\ClpIRandom.pas',
+  ClpIRandomDsaKCalculator in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\SignerCalculators\ClpIRandomDsaKCalculator.pas',
+  ClpIRandomGenerator in '..\..\CryptoLib\src\Interfaces\Rngs\ClpIRandomGenerator.pas',
+  ClpIRawAgreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIRawAgreement.pas',
+  ClpIRijndaelEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIRijndaelEngine.pas',
+  ClpIRsa in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIRsa.pas',
+  ClpIRsaBlindedEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIRsaBlindedEngine.pas',
+  ClpIRsaBlindingEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIRsaBlindingEngine.pas',
+  ClpIRsaGenerators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIRsaGenerators.pas',
+  ClpIRsaCoreEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIRsaCoreEngine.pas',
+  ClpIRsaDigestSigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpIRsaDigestSigner.pas',
+  ClpIRsaEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIRsaEngine.pas',
+  ClpIRsaParameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIRsaParameters.pas',
+  ClpISalsa20Engine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpISalsa20Engine.pas',
+  ClpIScalarSplitParameters in '..\..\CryptoLib\src\Interfaces\Math\EC\Endo\ClpIScalarSplitParameters.pas',
+  ClpIScryptParametersGenerator in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIScryptParametersGenerator.pas',
+  ClpISecECAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\Sec\ClpISecECAsn1Objects.pas',
+  ClpISecP256K1Custom in '..\..\CryptoLib\src\Interfaces\Math\EC\Custom\Sec\ClpISecP256K1Custom.pas',
+  ClpISecP256R1Custom in '..\..\CryptoLib\src\Interfaces\Math\EC\Custom\Sec\ClpISecP256R1Custom.pas',
+  ClpISecP384R1Custom in '..\..\CryptoLib\src\Interfaces\Math\EC\Custom\Sec\ClpISecP384R1Custom.pas',
+  ClpISecP521R1Custom in '..\..\CryptoLib\src\Interfaces\Math\EC\Custom\Sec\ClpISecP521R1Custom.pas',
+  ClpISecT283K1Custom in '..\..\CryptoLib\src\Interfaces\Math\EC\Custom\Sec\ClpISecT283K1Custom.pas',
+  ClpISecureRandom in '..\..\CryptoLib\src\Interfaces\Crypto\Randoms\ClpISecureRandom.pas',
+  ClpISignatureFactory in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpISignatureFactory.pas',
+  ClpISigner in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\ClpISigner.pas',
+  ClpIDsaEncoding in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\SignerEncodings\ClpIDsaEncoding.pas',
+  ClpIStandardDsaEncoding in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\SignerEncodings\ClpIStandardDsaEncoding.pas',
+  ClpIPlainDsaEncoding in '..\..\CryptoLib\src\Interfaces\Crypto\Signers\SignerEncodings\ClpIPlainDsaEncoding.pas',
+  ClpIso18033KdfParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpIso18033KdfParameters.pas',
+  ClpISO9796d1Encoding in '..\..\CryptoLib\src\Crypto\Encodings\ClpISO9796d1Encoding.pas',
+  ClpIsoTrailers in '..\..\CryptoLib\src\Crypto\Signers\ClpIsoTrailers.pas',
+  ClpISpeckEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpISpeckEngine.pas',
+  ClpISpeckLegacyEngine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpISpeckLegacyEngine.pas',
+  ClpIStreamCalculator in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIStreamCalculator.pas',
+  ClpIStreamCipher in '..\..\CryptoLib\src\Interfaces\Crypto\Ciphers\ClpIStreamCipher.pas',
+  ClpIValidityPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIValidityPreCompInfo.pas',
+  ClpIVerifier in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIVerifier.pas',
+  ClpIVerifierFactory in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIVerifierFactory.pas',
+  ClpIVerifierFactoryProvider in '..\..\CryptoLib\src\Interfaces\Crypto\Operators\ClpIVerifierFactoryProvider.pas',
+  ClpIWNafPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIWNafPreCompInfo.pas',
+  ClpIWTauNafPreCompInfo in '..\..\CryptoLib\src\Interfaces\Math\EC\Multiplier\ClpIWTauNafPreCompInfo.pas',
+  ClpIX25519Agreement in '..\..\CryptoLib\src\Interfaces\Crypto\Agreements\ClpIX25519Agreement.pas',
+  ClpIX25519Parameters in '..\..\CryptoLib\src\Interfaces\Crypto\Parameters\ClpIX25519Parameters.pas',
+  ClpIX25519Generators in '..\..\CryptoLib\src\Interfaces\Crypto\Generators\ClpIX25519Generators.pas',
+  ClpIX509Asn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509Asn1Objects.pas',
+  ClpIX509Asn1Generators in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509Asn1Generators.pas',
+  ClpIX509NameEntryConverter in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509NameEntryConverter.pas',
+  ClpIX509NameTokenizer in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509NameTokenizer.pas',
+  ClpIX9DHAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9DHAsn1Objects.pas',
+  ClpIX9ECAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9ECAsn1Objects.pas',
+  ClpIX9ECParametersHolder in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9ECParametersHolder.pas',
+  ClpIXSalsa20Engine in '..\..\CryptoLib\src\Interfaces\Crypto\Engines\ClpIXSalsa20Engine.pas',
+  ClpIZTauElement in '..\..\CryptoLib\src\Interfaces\Math\EC\Abc\ClpIZTauElement.pas',
+  ClpKdf1BytesGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpKdf1BytesGenerator.pas',
+  ClpKdf2BytesGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpKdf2BytesGenerator.pas',
+  ClpKdfParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpKdfParameters.pas',
+  ClpKeyEncoder in '..\..\CryptoLib\src\Crypto\ClpKeyEncoder.pas',
+  ClpKeyGenerationParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpKeyGenerationParameters.pas',
+  ClpKeyParameter in '..\..\CryptoLib\src\Crypto\Parameters\ClpKeyParameter.pas',
+  ClpKMac in '..\..\CryptoLib\src\Crypto\Macs\ClpKMac.pas',
+  ClpLongArray in '..\..\CryptoLib\src\Math\EC\ClpLongArray.pas',
+  ClpMacUtilities in '..\..\CryptoLib\src\Crypto\Macs\ClpMacUtilities.pas',
+  ClpMiscObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Misc\ClpMiscObjectIdentifiers.pas',
+  ClpMultipliers in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpMultipliers.pas',
+  ClpNistNamedCurves in '..\..\CryptoLib\src\Asn1\Nist\ClpNistNamedCurves.pas',
+  ClpNistObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Nist\ClpNistObjectIdentifiers.pas',
+  ClpNoOpDigest in '..\..\CryptoLib\src\Crypto\Digests\ClpNoOpDigest.pas',
+  ClpOaepEncoding in '..\..\CryptoLib\src\Crypto\Encodings\ClpOaepEncoding.pas',
+  ClpOidTokenizer in '..\..\CryptoLib\src\Asn1\ClpOidTokenizer.pas',
+  ClpOiwObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Oiw\ClpOiwObjectIdentifiers.pas',
+  ClpPaddedBufferedBlockCipher in '..\..\CryptoLib\src\Crypto\Paddings\ClpPaddedBufferedBlockCipher.pas',
+  ClpISO10126d2Padding in '..\..\CryptoLib\src\Crypto\Paddings\ClpISO10126d2Padding.pas',
+  ClpISO7816d4Padding in '..\..\CryptoLib\src\Crypto\Paddings\ClpISO7816d4Padding.pas',
+  ClpPkcs7Padding in '..\..\CryptoLib\src\Crypto\Paddings\ClpPkcs7Padding.pas',
+  ClpTBCPadding in '..\..\CryptoLib\src\Crypto\Paddings\ClpTBCPadding.pas',
+  ClpX923Padding in '..\..\CryptoLib\src\Crypto\Paddings\ClpX923Padding.pas',
+  ClpZeroBytePadding in '..\..\CryptoLib\src\Crypto\Paddings\ClpZeroBytePadding.pas',
+  ClpParametersWithIV in '..\..\CryptoLib\src\Crypto\Parameters\ClpParametersWithIV.pas',
+  ClpParametersWithRandom in '..\..\CryptoLib\src\Crypto\Parameters\ClpParametersWithRandom.pas',
+  ClpParameterUtilities in '..\..\CryptoLib\src\Crypto\Parameters\ClpParameterUtilities.pas',
+  ClpPascalCoinECIESKdfBytesGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpPascalCoinECIESKdfBytesGenerator.pas',
+  ClpPascalCoinIesEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpPascalCoinIesEngine.pas',
+  ClpPbeParametersGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpPbeParametersGenerator.pas',
+  ClpPemObjects in '..\..\CryptoLib\src\Pem\ClpPemObjects.pas',
+  ClpPkcs1Encoding in '..\..\CryptoLib\src\Crypto\Encodings\ClpPkcs1Encoding.pas',
+  ClpPkcs5S2ParametersGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpPkcs5S2ParametersGenerator.pas',
+  ClpPkcsAsn1Objects in '..\..\CryptoLib\src\Asn1\Pkcs\ClpPkcsAsn1Objects.pas',
+  ClpPkcsObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Pkcs\ClpPkcsObjectIdentifiers.pas',
+  ClpPlatformUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpPlatformUtilities.pas',
+  ClpPrehash in '..\..\CryptoLib\src\Crypto\Digests\ClpPrehash.pas',
+  ClpPrimeField in '..\..\CryptoLib\src\Math\Field\ClpPrimeField.pas',
+  ClpPrivateKeyFactory in '..\..\CryptoLib\src\Factories\ClpPrivateKeyFactory.pas',
+  ClpPssSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpPssSigner.pas',
+  ClpPublicKeyFactory in '..\..\CryptoLib\src\Factories\ClpPublicKeyFactory.pas',
+  ClpRandom in '..\..\CryptoLib\src\Crypto\Randoms\ClpRandom.pas',
+  ClpRandomDsaKCalculator in '..\..\CryptoLib\src\Crypto\Signers\SignerCalculators\ClpRandomDsaKCalculator.pas',
+  ClpRfc5280Asn1Utilities in '..\..\CryptoLib\src\Asn1\X509\ClpRfc5280Asn1Utilities.pas',
+  ClpRijndaelEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpRijndaelEngine.pas',
+  ClpRosstandartObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Rosstandart\ClpRosstandartObjectIdentifiers.pas',
+  ClpRsaBlindedEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpRsaBlindedEngine.pas',
+  ClpRsaBlindingEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpRsaBlindingEngine.pas',
+  ClpRsaGenerators in '..\..\CryptoLib\src\Crypto\Generators\ClpRsaGenerators.pas',
+  ClpRsaCoreEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpRsaCoreEngine.pas',
+  ClpRsaDigestSigner in '..\..\CryptoLib\src\Crypto\Signers\ClpRsaDigestSigner.pas',
+  ClpRsaEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpRsaEngine.pas',
+  ClpRsaParameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpRsaParameters.pas',
+  ClpSalsa20Engine in '..\..\CryptoLib\src\Crypto\Engines\ClpSalsa20Engine.pas',
+  ClpScalarSplitParameters in '..\..\CryptoLib\src\Math\EC\Endo\ClpScalarSplitParameters.pas',
+  ClpECPointMaps in '..\..\CryptoLib\src\Math\EC\ClpECPointMaps.pas',
+  ClpScryptParametersGenerator in '..\..\CryptoLib\src\Crypto\Generators\ClpScryptParametersGenerator.pas',
+  ClpSecECAsn1Objects in '..\..\CryptoLib\src\Asn1\Sec\ClpSecECAsn1Objects.pas',
+  ClpSecNamedCurves in '..\..\CryptoLib\src\Asn1\Sec\ClpSecNamedCurves.pas',
+  ClpSecObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Sec\ClpSecObjectIdentifiers.pas',
+  ClpSecP256K1Custom in '..\..\CryptoLib\src\Math\EC\Custom\Sec\ClpSecP256K1Custom.pas',
+  ClpSecP256R1Custom in '..\..\CryptoLib\src\Math\EC\Custom\Sec\ClpSecP256R1Custom.pas',
+  ClpSecP384R1Custom in '..\..\CryptoLib\src\Math\EC\Custom\Sec\ClpSecP384R1Custom.pas',
+  ClpSecP521R1Custom in '..\..\CryptoLib\src\Math\EC\Custom\Sec\ClpSecP521R1Custom.pas',
+  ClpSecT283K1Custom in '..\..\CryptoLib\src\Math\EC\Custom\Sec\ClpSecT283K1Custom.pas',
+  ClpSecureRandom in '..\..\CryptoLib\src\Crypto\Randoms\ClpSecureRandom.pas',
+  ClpWeakRef in '..\..\CryptoLib\src\Misc\ClpWeakRef.pas',
+  ClpStandardDsaEncoding in '..\..\CryptoLib\src\Crypto\Signers\SignerEncodings\ClpStandardDsaEncoding.pas',
+  ClpPlainDsaEncoding in '..\..\CryptoLib\src\Crypto\Signers\SignerEncodings\ClpPlainDsaEncoding.pas',
+  ClpSignerSink in '..\..\CryptoLib\src\Crypto\IO\ClpSignerSink.pas',
+  ClpScalar25519 in '..\..\CryptoLib\src\Math\EC\Rfc8032\ClpScalar25519.pas',
+  ClpScalarUtilities in '..\..\CryptoLib\src\Math\EC\Rfc8032\ClpScalarUtilities.pas',
+  ClpSignerUtilities in '..\..\CryptoLib\src\Crypto\Signers\ClpSignerUtilities.pas',
+  ClpSimpleBigDecimal in '..\..\CryptoLib\src\Math\EC\Abc\ClpSimpleBigDecimal.pas',
+  ClpSpeckEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpSpeckEngine.pas',
+  ClpSpeckLegacyEngine in '..\..\CryptoLib\src\Crypto\Engines\ClpSpeckLegacyEngine.pas',
+  ClpStreams in '..\..\CryptoLib\src\IO\ClpStreams.pas',
+  ClpStreamUtilities in '..\..\CryptoLib\src\IO\ClpStreamUtilities.pas',
+  ClpStringUtilities in '..\..\CryptoLib\src\GeneralUtilities\ClpStringUtilities.pas',
+  ClpSubjectPublicKeyInfoFactory in '..\..\CryptoLib\src\Factories\ClpSubjectPublicKeyInfoFactory.pas',
+  ClpTeleTrusTNamedCurves in '..\..\CryptoLib\src\Asn1\TeleTrust\ClpTeleTrusTNamedCurves.pas',
+  ClpTeleTrusTObjectIdentifiers in '..\..\CryptoLib\src\Asn1\TeleTrust\ClpTeleTrusTObjectIdentifiers.pas',
+  ClpTnaf in '..\..\CryptoLib\src\Math\EC\Abc\ClpTnaf.pas',
+  ClpValidityPreCompInfo in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpValidityPreCompInfo.pas',
+  ClpWNafPreCompInfo in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpWNafPreCompInfo.pas',
+  ClpWTauNafPreCompInfo in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpWTauNafPreCompInfo.pas',
+  ClpWnaf in '..\..\CryptoLib\src\Math\EC\Rfc8032\ClpWnaf.pas',
+  ClpX25519 in '..\..\CryptoLib\src\Math\EC\Rfc7748\ClpX25519.pas',
+  ClpX25519Agreement in '..\..\CryptoLib\src\Crypto\Agreements\ClpX25519Agreement.pas',
+  ClpX25519Field in '..\..\CryptoLib\src\Math\EC\Rfc7748\ClpX25519Field.pas',
+  ClpX25519Parameters in '..\..\CryptoLib\src\Crypto\Parameters\ClpX25519Parameters.pas',
+  ClpX25519Generators in '..\..\CryptoLib\src\Crypto\Generators\ClpX25519Generators.pas',
+  ClpX509Asn1Objects in '..\..\CryptoLib\src\Asn1\X509\ClpX509Asn1Objects.pas',
+  ClpX509DefaultEntryConverter in '..\..\CryptoLib\src\Asn1\X509\ClpX509DefaultEntryConverter.pas',
+  ClpX509Extension in '..\..\CryptoLib\src\Asn1\X509\ClpX509Extension.pas',
+  ClpX509Asn1Generators in '..\..\CryptoLib\src\Asn1\X509\ClpX509Asn1Generators.pas',
+  ClpX509NameEntryConverter in '..\..\CryptoLib\src\Asn1\X509\ClpX509NameEntryConverter.pas',
+  ClpX509NameTokenizer in '..\..\CryptoLib\src\Asn1\X509\ClpX509NameTokenizer.pas',
+  ClpX509ObjectIdentifiers in '..\..\CryptoLib\src\Asn1\X509\ClpX509ObjectIdentifiers.pas',
+  ClpX509SignatureUtilities in '..\..\CryptoLib\src\Asn1\X509\ClpX509SignatureUtilities.pas',
+  ClpX509ExtensionUtilities in '..\..\CryptoLib\src\X509\Extension\ClpX509ExtensionUtilities.pas',
+  ClpAttributeCertificateHolder in '..\..\CryptoLib\src\X509\ClpAttributeCertificateHolder.pas',
+  ClpAttributeCertificateIssuer in '..\..\CryptoLib\src\X509\ClpAttributeCertificateIssuer.pas',
+  ClpDeltaCertificateTool in '..\..\CryptoLib\src\X509\ClpDeltaCertificateTool.pas',
+  ClpX509AttrCertParser in '..\..\CryptoLib\src\X509\ClpX509AttrCertParser.pas',
+  ClpX509Attribute in '..\..\CryptoLib\src\X509\ClpX509Attribute.pas',
+  ClpX509Certificate in '..\..\CryptoLib\src\X509\ClpX509Certificate.pas',
+  ClpX509CertificateParser in '..\..\CryptoLib\src\X509\ClpX509CertificateParser.pas',
+  ClpX509Crl in '..\..\CryptoLib\src\X509\ClpX509Crl.pas',
+  ClpX509CrlEntry in '..\..\CryptoLib\src\X509\ClpX509CrlEntry.pas',
+  ClpX509CrlParser in '..\..\CryptoLib\src\X509\ClpX509CrlParser.pas',
+  ClpX509ExtensionBase in '..\..\CryptoLib\src\X509\ClpX509ExtensionBase.pas',
+  ClpX509Generators in '..\..\CryptoLib\src\X509\ClpX509Generators.pas',
+  ClpX509Utilities in '..\..\CryptoLib\src\X509\ClpX509Utilities.pas',
+  ClpX509V2AttributeCertificate in '..\..\CryptoLib\src\X509\ClpX509V2AttributeCertificate.pas',
+  ClpIX509Generators in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509Generators.pas',
+  ClpIAttributeCertificateHolder in '..\..\CryptoLib\src\Interfaces\X509\ClpIAttributeCertificateHolder.pas',
+  ClpIAttributeCertificateIssuer in '..\..\CryptoLib\src\Interfaces\X509\ClpIAttributeCertificateIssuer.pas',
+  ClpIX509Attribute in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509Attribute.pas',
+  ClpIX509V2AttributeCertificate in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509V2AttributeCertificate.pas',
+  ClpX931Signer in '..\..\CryptoLib\src\Crypto\Signers\ClpX931Signer.pas',
+  ClpX9DHAsn1Objects in '..\..\CryptoLib\src\Asn1\X9\ClpX9DHAsn1Objects.pas',
+  ClpX9ECAsn1Objects in '..\..\CryptoLib\src\Asn1\X9\ClpX9ECAsn1Objects.pas',
+  ClpX9ECParametersHolder in '..\..\CryptoLib\src\Asn1\X9\ClpX9ECParametersHolder.pas',
+  ClpX9ObjectIdentifiers in '..\..\CryptoLib\src\Asn1\X9\ClpX9ObjectIdentifiers.pas',
+  ClpXSalsa20Engine in '..\..\CryptoLib\src\Crypto\Engines\ClpXSalsa20Engine.pas',
+  ClpZTauElement in '..\..\CryptoLib\src\Math\EC\Abc\ClpZTauElement.pas',
+  ClpAppleRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpAppleRandomProvider.pas',
+  ClpGenericBSDRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpGenericBSDRandomProvider.pas',
+  ClpLinuxRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpLinuxRandomProvider.pas',
+  ClpSolarisRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpSolarisRandomProvider.pas',
+  ClpUnixRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpUnixRandomProvider.pas',
+  ClpWindowsRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpWindowsRandomProvider.pas',
+  ClpRandomNumberGenerator in '..\..\CryptoLib\src\Rngs\ClpRandomNumberGenerator.pas',
+  ClpIRandomSourceProvider in '..\..\CryptoLib\src\Interfaces\Rngs\Providers\ClpIRandomSourceProvider.pas',
+  ClpOSRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpOSRandomProvider.pas',
+  ClpIRandomNumberGenerator in '..\..\CryptoLib\src\Interfaces\Rngs\ClpIRandomNumberGenerator.pas',
+  ClpAesRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpAesRandomProvider.pas',
+  ClpDevRandomReader in '..\..\CryptoLib\src\Rngs\Providers\ClpDevRandomReader.pas',
+  ClpBaseRandomProvider in '..\..\CryptoLib\src\Rngs\Providers\ClpBaseRandomProvider.pas',
+  ClpAsn1Parsers in '..\..\CryptoLib\src\Asn1\ClpAsn1Parsers.pas',
+  ClpAsn1Core in '..\..\CryptoLib\src\Asn1\ClpAsn1Core.pas',
+  ClpIAsn1Parsers in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIAsn1Parsers.pas',
+  ClpIAsn1Core in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIAsn1Core.pas',
+  ClpAsn1Tags in '..\..\CryptoLib\src\Asn1\ClpAsn1Tags.pas',
+  ClpIAsn1Encodings in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIAsn1Encodings.pas',
+  ClpAsn1Encodings in '..\..\CryptoLib\src\Asn1\ClpAsn1Encodings.pas',
+  ClpAsn1Generators in '..\..\CryptoLib\src\Asn1\ClpAsn1Generators.pas',
+  ClpIAsn1Generators in '..\..\CryptoLib\src\Interfaces\Asn1\ClpIAsn1Generators.pas',
+  ClpPkcs10CertificationRequest in '..\..\CryptoLib\src\Pkcs\ClpPkcs10CertificationRequest.pas',
+  ClpIX509Certificate in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509Certificate.pas',
+  ClpIX509CertificateParser in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509CertificateParser.pas',
+  ClpIX509CrlEntry in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509CrlEntry.pas',
+  ClpIX509Crl in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509Crl.pas',
+  ClpIX509CrlParser in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509CrlParser.pas',
+  ClpIX509AttrCertParser in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509AttrCertParser.pas',
+  ClpIX509Extension in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509Extension.pas',
+  ClpIPkcs10CertificationRequest in '..\..\CryptoLib\src\Interfaces\Pkcs\ClpIPkcs10CertificationRequest.pas',
+  ClpX9IntegerConverter in '..\..\CryptoLib\src\Asn1\X9\ClpX9IntegerConverter.pas',
+  ClpPkcsRsaAsn1Objects in '..\..\CryptoLib\src\Asn1\Pkcs\ClpPkcsRsaAsn1Objects.pas',
+  ClpIPkcsRsaAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\Pkcs\ClpIPkcsRsaAsn1Objects.pas',
+  ClpIX509DsaAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509DsaAsn1Objects.pas',
+  ClpIX509RsaAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509RsaAsn1Objects.pas',
+  ClpX509DsaAsn1Objects in '..\..\CryptoLib\src\Asn1\X509\ClpX509DsaAsn1Objects.pas',
+  ClpX509RsaAsn1Objects in '..\..\CryptoLib\src\Asn1\X509\ClpX509RsaAsn1Objects.pas',
+  ClpBinaryPrimitives in '..\..\CryptoLib\src\Misc\ClpBinaryPrimitives.pas',
+  ClpBitOperations in '..\..\CryptoLib\src\Misc\ClpBitOperations.pas',
+  ClpPack in '..\..\CryptoLib\src\Misc\ClpPack.pas',
+  ClpBits in '..\..\CryptoLib\src\Math\Raw\ClpBits.pas',
+  ClpMod in '..\..\CryptoLib\src\Math\Raw\ClpMod.pas',
+  ClpInterleave in '..\..\CryptoLib\src\Math\Raw\ClpInterleave.pas',
+  ClpNat in '..\..\CryptoLib\src\Math\Raw\ClpNat.pas',
+  ClpNat128 in '..\..\CryptoLib\src\Math\Raw\ClpNat128.pas',
+  ClpNat160 in '..\..\CryptoLib\src\Math\Raw\ClpNat160.pas',
+  ClpNat192 in '..\..\CryptoLib\src\Math\Raw\ClpNat192.pas',
+  ClpNat224 in '..\..\CryptoLib\src\Math\Raw\ClpNat224.pas',
+  ClpNat256 in '..\..\CryptoLib\src\Math\Raw\ClpNat256.pas',
+  ClpNat320 in '..\..\CryptoLib\src\Math\Raw\ClpNat320.pas',
+  ClpNat384 in '..\..\CryptoLib\src\Math\Raw\ClpNat384.pas',
+  ClpNat448 in '..\..\CryptoLib\src\Math\Raw\ClpNat448.pas',
+  ClpNat512 in '..\..\CryptoLib\src\Math\Raw\ClpNat512.pas',
+  ClpNat576 in '..\..\CryptoLib\src\Math\Raw\ClpNat576.pas',
+  ClpNullable in '..\..\CryptoLib\src\Misc\ClpNullable.pas',
+  ClpECPoint in '..\..\CryptoLib\src\Math\EC\ClpECPoint.pas',
+  ClpECFieldElement in '..\..\CryptoLib\src\Math\EC\ClpECFieldElement.pas',
+  ClpECLookupTables in '..\..\CryptoLib\src\Math\EC\ClpECLookupTables.pas',
+  ClpEndoUtilities in '..\..\CryptoLib\src\Math\EC\Endo\ClpEndoUtilities.pas',
+  ClpWNafUtilities in '..\..\CryptoLib\src\Math\EC\Multiplier\ClpWNafUtilities.pas',
+  ClpCustomNamedCurves in '..\..\CryptoLib\src\Crypto\EC\ClpCustomNamedCurves.pas',
+  ClpECUtilities in '..\..\CryptoLib\src\Crypto\EC\ClpECUtilities.pas',
+  ClpX962NamedCurves in '..\..\CryptoLib\src\Asn1\X9\ClpX962NamedCurves.pas',
+  ClpX509NameBuilder in '..\..\CryptoLib\src\X509\ClpX509NameBuilder.pas',
+  ClpIX509NameBuilder in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509NameBuilder.pas',
+  ClpCmsAsn1Objects in '..\..\CryptoLib\src\Asn1\Cms\ClpCmsAsn1Objects.pas',
+  ClpCmsObjectIdentifiers in '..\..\CryptoLib\src\Asn1\Cms\ClpCmsObjectIdentifiers.pas',
+  ClpCmsParsers in '..\..\CryptoLib\src\Asn1\Cms\ClpCmsParsers.pas',
+  ClpICmsAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\Cms\ClpICmsAsn1Objects.pas',
+  ClpICmsParsers in '..\..\CryptoLib\src\Interfaces\Asn1\Cms\ClpICmsParsers.pas',
+  ClpCurve25519KeyUtilities in '..\..\CryptoLib\src\Crypto\Parameters\ClpCurve25519KeyUtilities.pas',
+  ClpOpenSslMiscPemGenerator in '..\..\CryptoLib\src\OpenSsl\ClpOpenSslMiscPemGenerator.pas',
+  ClpPrivateKeyInfoFactory in '..\..\CryptoLib\src\Factories\ClpPrivateKeyInfoFactory.pas',
+  ClpPkcsDHAsn1Objects in '..\..\CryptoLib\src\Asn1\Pkcs\ClpPkcsDHAsn1Objects.pas',
+  ClpIPkcsDHAsn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\Pkcs\ClpIPkcsDHAsn1Objects.pas',
+  ClpOpenSslPemWriter in '..\..\CryptoLib\src\OpenSsl\ClpOpenSslPemWriter.pas',
+  ClpIOpenSslPemWriter in '..\..\CryptoLib\src\Interfaces\OpenSsl\ClpIOpenSslPemWriter.pas',
+  ClpOpenSslPemReader in '..\..\CryptoLib\src\OpenSsl\ClpOpenSslPemReader.pas',
+  ClpIOpenSslPemReader in '..\..\CryptoLib\src\Interfaces\OpenSsl\ClpIOpenSslPemReader.pas',
+  ClpIPemParser in '..\..\CryptoLib\src\Interfaces\Pem\ClpIPemParser.pas',
+  ClpIPemReader in '..\..\CryptoLib\src\Interfaces\Pem\ClpIPemReader.pas',
+  ClpIPemWriter in '..\..\CryptoLib\src\Interfaces\Pem\ClpIPemWriter.pas',
+  ClpPemParser in '..\..\CryptoLib\src\Pem\ClpPemParser.pas',
+  ClpPemReader in '..\..\CryptoLib\src\Pem\ClpPemReader.pas',
+  ClpPemWriter in '..\..\CryptoLib\src\Pem\ClpPemWriter.pas';
+
+begin
+  TClpLogger.SetDefaultLogger(TConsoleLogger.Create('Examples', TLogLevel.Info) as ILogger);
+  try
+    TExampleExplorer.Execute;
+  except
+    on E: Exception do
+      Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.

CryptoLib.Examples/src/ClpConsoleLogger.pas

@@ -0,0 +1,96 @@
+unit ClpConsoleLogger;
+
+interface
+
+uses
+  SysUtils,
+  ClpLogger;
+
+type
+  TConsoleLogger = class(TInterfacedObject, ILogger)
+  private
+    FCategory: string;
+    FMinLevel: TLogLevel;
+    function LevelToString(ALevel: TLogLevel): string;
+  public
+    constructor Create(const ACategory: string = ''; AMinLevel: TLogLevel = TLogLevel.Trace);
+    procedure Log(ALevel: TLogLevel; const AMsg: string);
+    procedure LogTrace(const AMsg: string);
+    procedure LogDebug(const AMsg: string);
+    procedure LogInformation(const AMsg: string);
+    procedure LogWarning(const AMsg: string);
+    procedure LogError(const AMsg: string);
+    procedure LogCritical(const AMsg: string);
+    function IsEnabled(ALevel: TLogLevel): Boolean;
+  end;
+
+implementation
+
+const
+  LevelNames: array[TLogLevel] of string = ('TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL');
+
+{ TConsoleLogger }
+
+constructor TConsoleLogger.Create(const ACategory: string; AMinLevel: TLogLevel);
+begin
+  inherited Create;
+  FCategory := ACategory;
+  FMinLevel := AMinLevel;
+end;
+
+function TConsoleLogger.LevelToString(ALevel: TLogLevel): string;
+begin
+  Result := LevelNames[ALevel];
+end;
+
+function TConsoleLogger.IsEnabled(ALevel: TLogLevel): Boolean;
+begin
+  Result := Ord(ALevel) >= Ord(FMinLevel);
+end;
+
+procedure TConsoleLogger.Log(ALevel: TLogLevel; const AMsg: string);
+var
+  Prefix, CategoryPart, Line: string;
+begin
+  if not IsEnabled(ALevel) then
+    Exit;
+  Prefix := FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', Now) + ' [' + LevelToString(ALevel) + '] ';
+  if FCategory <> '' then
+    CategoryPart := '[' + FCategory + ']: '
+  else
+    CategoryPart := '';
+  Line := Prefix + CategoryPart + AMsg;
+  Writeln(Line);
+end;
+
+procedure TConsoleLogger.LogTrace(const AMsg: string);
+begin
+  Log(TLogLevel.Trace, AMsg);
+end;
+
+procedure TConsoleLogger.LogDebug(const AMsg: string);
+begin
+  Log(TLogLevel.Debug, AMsg);
+end;
+
+procedure TConsoleLogger.LogInformation(const AMsg: string);
+begin
+  Log(TLogLevel.Info, AMsg);
+end;
+
+procedure TConsoleLogger.LogWarning(const AMsg: string);
+begin
+  Log(TLogLevel.Warn, AMsg);
+end;
+
+procedure TConsoleLogger.LogError(const AMsg: string);
+begin
+  Log(TLogLevel.Error, AMsg);
+end;
+
+procedure TConsoleLogger.LogCritical(const AMsg: string);
+begin
+  Log(TLogLevel.Fatal, AMsg);
+end;
+
+end.

CryptoLib.Examples/src/ClpExampleBase.pas

@@ -0,0 +1,27 @@
+unit ClpExampleBase;
+
+interface
+
+uses
+  ClpLogger;
+
+type
+  IExample = interface(IInterface)
+    ['{EC8F2122-75DB-4F47-8007-B912D7001C8E}']
+    procedure Run;
+  end;
+
+  TExampleBase = class(TInterfacedObject, IExample)
+  public
+    function Logger: ILogger;
+    procedure Run; virtual; abstract;
+  end;
+
+implementation
+
+function TExampleBase.Logger: ILogger;
+begin
+  Result := TClpLogger.GetDefaultLogger;
+end;
+
+end.

CryptoLib.Examples/src/ClpExampleExplorer.pas

@@ -0,0 +1,93 @@
+unit ClpExampleExplorer;
+
+interface
+
+type
+  TExampleExplorer = class
+  public
+    class procedure Execute;
+  end;
+
+implementation
+
+uses
+  SysUtils,
+  Rtti,
+  TypInfo,
+  Generics.Collections,
+  ClpExampleBase;
+
+class procedure TExampleExplorer.Execute;
+var
+  Ctx: TRttiContext;
+  LType: TRttiType;
+  LInst: TRttiInstanceType;
+  LCreate: TRttiMethod;
+  Examples: TList<TRttiInstanceType>;
+  Option: string;
+  I, Idx: Integer;
+  LExample: IExample;
+  N: Integer;
+begin
+  Examples := TList<TRttiInstanceType>.Create;
+  try
+    Ctx := TRttiContext.Create;
+    for LType in Ctx.GetTypes do
+    begin
+      if LType is TRttiInstanceType then
+      begin
+        LInst := TRttiInstanceType(LType);
+        if (LInst.MetaclassType <> nil) and LInst.MetaclassType.InheritsFrom(TExampleBase)
+          and (LInst.MetaclassType <> TExampleBase) then
+        begin
+          LCreate := LInst.GetMethod('Create');
+          if (LCreate <> nil) and (Length(LCreate.GetParameters) = 0) then
+            Examples.Add(LInst);
+        end;
+      end;
+    end;
+
+    if Examples.Count = 0 then
+    begin
+      Writeln('No example classes found.');
+      Exit;
+    end;
+
+    while True do
+    begin
+      Writeln('Choose an example to run (type exit/quit to leave):');
+      for N := 0 to Examples.Count - 1 do
+        Writeln(Format('  %d: %s', [N, Examples[N].Name]));
+
+      Readln(Option);
+      if SameText(Trim(Option), 'exit') or SameText(Trim(Option), 'quit') then
+        Break;
+
+      if not TryStrToInt(Trim(Option), I) or (I < 0) or (I >= Examples.Count) then
+      begin
+        Writeln('Invalid option. Enter a number between 0 and ', Examples.Count - 1, '.');
+        Continue;
+      end;
+
+      Idx := I;
+      try
+        LCreate := Examples[Idx].GetMethod('Create');
+        if (LCreate <> nil) and Supports(LCreate.Invoke(Examples[Idx].MetaclassType, []).AsObject, IExample, LExample) then
+        begin
+          try
+            LExample.Run;
+          finally
+            LExample := nil;
+          end;
+        end;
+      except
+        on E: Exception do
+          Writeln(E.ClassName, ': ', E.Message);
+      end;
+    end;
+  finally
+    Examples.Free;
+  end;
+end;
+
+end.

CryptoLib.Examples/src/ClpLogger.pas

@@ -0,0 +1,42 @@
+unit ClpLogger;
+
+interface
+
+type
+  TLogLevel = (Trace, Debug, Info, Warn, Error, Fatal);
+
+  ILogger = interface(IInterface)
+    ['{E9BD7306-A6CD-49FA-88C6-8460FBB29E37}']
+    procedure Log(ALevel: TLogLevel; const AMsg: string);
+    procedure LogTrace(const AMsg: string);
+    procedure LogDebug(const AMsg: string);
+    procedure LogInformation(const AMsg: string);
+    procedure LogWarning(const AMsg: string);
+    procedure LogError(const AMsg: string);
+    procedure LogCritical(const AMsg: string);
+    function IsEnabled(ALevel: TLogLevel): Boolean;
+  end;
+
+  TClpLogger = class
+  private
+    class var FDefaultLogger: ILogger;
+  public
+    class procedure SetDefaultLogger(const ALogger: ILogger);
+    class function GetDefaultLogger: ILogger;
+  end;
+
+implementation
+
+{ TClpLogger }
+
+class procedure TClpLogger.SetDefaultLogger(const ALogger: ILogger);
+begin
+  FDefaultLogger := ALogger;
+end;
+
+class function TClpLogger.GetDefaultLogger: ILogger;
+begin
+  Result := FDefaultLogger;
+end;
+
+end.

CryptoLib.Examples/src/Examples/ClpCertificateExample.pas

@@ -0,0 +1,290 @@
+unit ClpCertificateExample;
+
+interface
+
+uses
+  SysUtils,
+  Classes,
+  Rtti,
+  DateUtils,
+  ClpGeneratorUtilities,
+  ClpSecureRandom,
+  ClpBigInteger,
+  ClpRsaParameters,
+  ClpIRsaParameters,
+  ClpDsaParameters,
+  ClpDsaGenerators,
+  ClpECParameters,
+  ClpIECParameters,
+  ClpECGenerators,
+  ClpECUtilities,
+  ClpIAsn1Objects,
+  ClpSecObjectIdentifiers,
+  ClpX509NameBuilder,
+  ClpIX509NameBuilder,
+  ClpX509Generators,
+  ClpIX509Asn1Objects,
+  ClpX509Asn1Objects,
+  ClpAsn1SignatureFactory,
+  ClpX509CrlParser,
+  ClpIX509CrlParser,
+  ClpIX509Crl,
+  ClpIX509Generators,
+  ClpX509ExtensionUtilities,
+  ClpSubjectPublicKeyInfoFactory,
+  ClpPkcs10CertificationRequest,
+  ClpIPkcs10CertificationRequest,
+  ClpIOpenSslPemWriter,
+  ClpOpenSslPemWriter,
+  ClpIAsymmetricCipherKeyPair,
+  ClpIAsymmetricCipherKeyPairGenerator,
+  ClpIAsymmetricKeyParameter,
+  ClpISignatureFactory,
+  ClpIKeyGenerationParameters,
+  ClpISecureRandom,
+  ClpCryptoLibTypes,
+  ClpIX509CrlEntry,
+  ClpIX9ECAsn1Objects,
+  ClpExampleBase;
+
+type
+  TCertRequestPem = record
+    PrivateKeyPem: string;
+    CertificateRequestPem: string;
+  end;
+
+  TCertificateExample = class(TExampleBase)
+  public
+    procedure Run; override;
+  private
+    procedure RunCrlCreateExport;
+    procedure RunCrlRsa;
+    procedure RunCrlImportVerify(const ACrlEncoded: TBytes; const AIssuerPublicKey: IAsymmetricKeyParameter);
+    procedure RunCertRequestCreateExportPem;
+    procedure RunCertRequestRsa(const ASignatureAlgorithm: string);
+    procedure RunCertRequestEc(const ACurveName: string; const ASignatureAlgorithm: string);
+    function BuildX509NameSubject: IX509Name;
+    function CreateCrlEncoded(const AKeyPair: IAsymmetricCipherKeyPair;
+      const AIssuer: IX509Name; const ASignatureAlgorithm: String): TBytes;
+    function CreateCertRequestPem(const AKeyPair: IAsymmetricCipherKeyPair;
+      const ASubject: IX509Name; const ASignatureAlgorithm: String): TCertRequestPem;
+  end;
+
+implementation
+
+function TCertificateExample.CreateCrlEncoded(const AKeyPair: IAsymmetricCipherKeyPair;
+  const AIssuer: IX509Name; const ASignatureAlgorithm: String): TBytes;
+var
+  LCrlGen: IX509V2CrlGenerator;
+  LCrl: IX509Crl;
+  LUtc: TDateTime;
+begin
+  LUtc := TTimeZone.Local.ToUniversalTime(Now);
+  LCrlGen := TX509V2CrlGenerator.Create();
+  LCrlGen.SetIssuerDN(AIssuer);
+  LCrlGen.SetThisUpdateUtc(LUtc);
+  LCrlGen.SetNextUpdateUtc(IncSecond(LUtc, 86400));
+  LCrlGen.AddCrlEntryUtc(TBigInteger.One, LUtc, 0);
+  LCrlGen.AddExtension(TX509Extensions.AuthorityKeyIdentifier, False,
+    TX509ExtensionUtilities.CreateAuthorityKeyIdentifier(TSubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(AKeyPair.Public)));
+  LCrl := LCrlGen.Generate(TAsn1SignatureFactory.Create(ASignatureAlgorithm, AKeyPair.Private, nil) as ISignatureFactory);
+  Result := LCrl.GetEncoded();
+end;
+
+procedure TCertificateExample.RunCrlRsa;
+var
+  LKpg: IAsymmetricCipherKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LIssuer: IX509Name;
+  LEncoded: TBytes;
+  LParser: IX509CrlParser;
+  LCrl: IX509Crl;
+  LRevoked: TCryptoLibGenericArray<IX509CrlEntry>;
+  LRevokedCount: Int32;
+begin
+  Logger.LogInformation('--- CRL: RSA ---');
+  LKpg := TGeneratorUtilities.GetKeyPairGenerator('RSA');
+  LKpg.Init(TRsaKeyGenerationParameters.Create(TBigInteger.ValueOf(65537),
+    TSecureRandom.Create() as ISecureRandom, 2048, 25) as IKeyGenerationParameters);
+  LKp := LKpg.GenerateKeyPair();
+  LIssuer := BuildX509NameSubject();
+  LEncoded := CreateCrlEncoded(LKp, LIssuer, 'SHA256WithRSAEncryption');
+  LParser := TX509CrlParser.Create();
+  LCrl := LParser.ReadCrl(LEncoded);
+  if LCrl <> nil then
+  begin
+    LRevoked := LCrl.GetRevokedCertificates();
+    if LRevoked <> nil then
+      LRevokedCount := System.Length(LRevoked)
+    else
+      LRevokedCount := 0;
+    Logger.LogInformation(Format('CRL created, common name %s, revoked count=%d, encoded length=%d',
+      [LCrl.GetIssuerDN().ToString(TX509Name.CN), LRevokedCount, System.Length(LEncoded)]));
+  end
+  else
+    Logger.LogInformation(Format('CRL created, encoded length=%d', [System.Length(LEncoded)]));
+  RunCrlImportVerify(LEncoded, LKp.Public);
+end;
+
+procedure TCertificateExample.RunCrlCreateExport;
+begin
+  Logger.LogInformation('--- Certificate example: CRL create and export ---');
+  RunCrlRsa;
+end;
+
+procedure TCertificateExample.RunCrlImportVerify(const ACrlEncoded: TBytes; const AIssuerPublicKey: IAsymmetricKeyParameter);
+var
+  LParser: IX509CrlParser;
+  LCrl: IX509Crl;
+  LRevoked: TCryptoLibGenericArray<IX509CrlEntry>;
+begin
+  Logger.LogInformation('--- Certificate example: CRL import and verify ---');
+  if (ACrlEncoded = nil) or (System.Length(ACrlEncoded) = 0) then
+  begin
+    Logger.LogWarning('No CRL bytes to parse.');
+    Exit;
+  end;
+  LParser := TX509CrlParser.Create();
+  LCrl := LParser.ReadCrl(ACrlEncoded);
+  if LCrl = nil then
+  begin
+    Logger.LogError('Failed to parse CRL.');
+    Exit;
+  end;
+  try
+    LCrl.Verify(AIssuerPublicKey);
+    Logger.LogInformation('CRL signature verification passed.');
+  except
+    on E: Exception do
+    begin
+      Logger.LogError('CRL verify failed: ' + E.Message);
+      Exit;
+    end;
+  end;
+  LRevoked := LCrl.GetRevokedCertificates();
+  if LRevoked <> nil then
+    Logger.LogInformation(Format('CRL revoked certificates count: %d', [System.Length(LRevoked)]))
+  else
+    Logger.LogInformation('CRL revoked certificates count: 0');
+  Logger.LogInformation(Format('CRL this update: %s', [FormatDateTime('yyyy-mm-dd hh:nn:ss', LCrl.ThisUpdate)]));
+end;
+
+function TCertificateExample.BuildX509NameSubject: IX509Name;
+var
+  LBuilder: IX509NameBuilder;
+begin
+  LBuilder := TX509NameBuilder.Create();
+  Result := LBuilder
+    .AddCommonName('CryptoLib')
+    .AddCountry('NG')
+    .AddOrganization('CryptoLib4Pascal')
+    .AddLocality('Alausa')
+    .AddState('Lagos')
+    .AddEmailAddress('[email protected]')
+    .Build();
+end;
+
+function TCertificateExample.CreateCertRequestPem(const AKeyPair: IAsymmetricCipherKeyPair;
+  const ASubject: IX509Name; const ASignatureAlgorithm: String): TCertRequestPem;
+var
+  LSignatureFactory: ISignatureFactory;
+  LReq: IPkcs10CertificationRequest;
+  LKeyStream, LReqStream: TStringStream;
+  LWriter: IOpenSslPemWriter;
+begin
+  LSignatureFactory := TAsn1SignatureFactory.Create(ASignatureAlgorithm, AKeyPair.Private, nil);
+  LReq := TPkcs10CertificationRequest.Create(LSignatureFactory, ASubject, AKeyPair.Public, nil) as IPkcs10CertificationRequest;
+
+  LKeyStream := TStringStream.Create('', TEncoding.ASCII);
+  try
+    LWriter := TOpenSslPemWriter.Create(LKeyStream);
+    LWriter.WriteObject(TValue.From<IAsymmetricKeyParameter>(AKeyPair.Private));
+    Result.PrivateKeyPem := LKeyStream.DataString;
+  finally
+    LKeyStream.Free;
+  end;
+
+  LReqStream := TStringStream.Create('', TEncoding.ASCII);
+  try
+    LWriter := TOpenSslPemWriter.Create(LReqStream);
+    LWriter.WriteObject(TValue.From<IPkcs10CertificationRequest>(LReq));
+    Result.CertificateRequestPem := LReqStream.DataString;
+  finally
+    LReqStream.Free;
+  end;
+end;
+
+procedure TCertificateExample.RunCertRequestRsa(const ASignatureAlgorithm: string);
+var
+  LKpg: IAsymmetricCipherKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LPem: TCertRequestPem;
+begin
+  Logger.LogInformation('--- Certificate request: RSA ---');
+  Logger.LogInformation('Algorithm: ' + ASignatureAlgorithm);
+  LKpg := TGeneratorUtilities.GetKeyPairGenerator('RSA');
+  LKpg.Init(TRsaKeyGenerationParameters.Create(TBigInteger.ValueOf(65537),
+    TSecureRandom.Create() as ISecureRandom, 2048, 25) as IKeyGenerationParameters);
+  LKp := LKpg.GenerateKeyPair();
+  LPem := CreateCertRequestPem(LKp, BuildX509NameSubject(), ASignatureAlgorithm);
+  Logger.LogInformation('Private key PEM (RSA ' + ASignatureAlgorithm + '):');
+  Logger.LogInformation(LPem.PrivateKeyPem);
+  Logger.LogInformation('Certificate request PEM (RSA ' + ASignatureAlgorithm + '):');
+  Logger.LogInformation(LPem.CertificateRequestPem);
+end;
+
+procedure TCertificateExample.RunCertRequestEc(const ACurveName: string; const ASignatureAlgorithm: string);
+var
+  LKpg: IAsymmetricCipherKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LSecRandom: ISecureRandom;
+  LDomainParams: IECDomainParameters;
+  LEcKeyParams: IKeyGenerationParameters;
+  LPem: TCertRequestPem;
+begin
+  Logger.LogInformation('--- Certificate request: EC ---');
+  Logger.LogInformation('Curve: ' + ACurveName + ', algorithm: ' + ASignatureAlgorithm);
+  LSecRandom := TSecureRandom.Create();
+  try
+    LDomainParams := TECDomainParameters.LookupName(ACurveName);
+  except
+    on E: EArgumentCryptoLibException do
+    begin
+      Logger.LogWarning('Curve "' + ACurveName + '" not found: ' + E.Message);
+      Exit;
+    end;
+    on E: EArgumentNilCryptoLibException do
+    begin
+      Logger.LogWarning('Curve name empty.');
+      Exit;
+    end;
+  end;
+  LEcKeyParams := TECKeyGenerationParameters.Create(LDomainParams, LSecRandom) as IKeyGenerationParameters;
+  LKpg := TGeneratorUtilities.GetKeyPairGenerator('EC');
+  LKpg.Init(LEcKeyParams);
+  LKp := LKpg.GenerateKeyPair();
+  LPem := CreateCertRequestPem(LKp, BuildX509NameSubject(), ASignatureAlgorithm);
+  Logger.LogInformation('Private key PEM (EC ' + ACurveName + ' ' + ASignatureAlgorithm + '):');
+  Logger.LogInformation(LPem.PrivateKeyPem);
+  Logger.LogInformation('Certificate request PEM (EC ' + ACurveName + ' ' + ASignatureAlgorithm + '):');
+  Logger.LogInformation(LPem.CertificateRequestPem);
+end;
+
+procedure TCertificateExample.RunCertRequestCreateExportPem;
+begin
+  Logger.LogInformation('--- Certificate example: Create and export certificate request as PEM ---');
+  RunCertRequestRsa('SHA-256withRSA');
+  RunCertRequestRsa('SHA256WITHRSAANDMGF1');
+
+  RunCertRequestEc('P-256', 'SHA256withECDSA');
+  RunCertRequestEc('secp256k1', 'SHA256withECDSA');
+
+end;
+
+procedure TCertificateExample.Run;
+begin
+  RunCrlCreateExport;
+  RunCertRequestCreateExportPem;
+end;
+
+end.

CryptoLib.Examples/src/Examples/ClpCipherExample.pas

@@ -0,0 +1,123 @@
+unit ClpCipherExample;
+
+interface
+
+uses
+  SysUtils,
+  ClpIBufferedCipher,
+  ClpCipherUtilities,
+  ClpParameterUtilities,
+  ClpParametersWithIV,
+  ClpConverters,
+  ClpSecureRandom,
+  ClpISecureRandom,
+  ClpArrayUtilities,
+  ClpCryptoLibTypes,
+  ClpICipherParameters,
+  ClpExampleBase;
+
+type
+  TCipherExample = class(TExampleBase)
+  private
+    function GetKeyAlgorithmName(const ACipherAlgorithm: string): string;
+    procedure RunCipherEncryptDecrypt(const ACipherAlgorithm: string;
+      const AParams: ICipherParameters);
+    procedure RunAesEncryptDecrypt(const ACipherAlgorithm: string;
+      AKeySizeBytes: Int32);
+  public
+    procedure Run; override;
+  end;
+
+implementation
+
+function TCipherExample.GetKeyAlgorithmName(const ACipherAlgorithm: string): string;
+var
+  LSlash: Int32;
+begin
+  LSlash := Pos('/', ACipherAlgorithm);
+  if LSlash > 0 then
+    Result := Copy(ACipherAlgorithm, 1, LSlash - 1)
+  else
+    Result := ACipherAlgorithm;
+end;
+
+procedure TCipherExample.RunCipherEncryptDecrypt(const ACipherAlgorithm: string;
+  const AParams: ICipherParameters);
+var
+  LCipher: IBufferedCipher;
+  LPlain, LCipherText, LDecrypted: TBytes;
+  LBlockSize, LOutOff, LCount: Int32;
+begin
+  Logger.LogInformation('Cipher: ' + ACipherAlgorithm);
+  LCipher := TCipherUtilities.GetCipher(ACipherAlgorithm);
+  if LCipher = nil then
+  begin
+    Logger.LogWarning('Cipher "' + ACipherAlgorithm + '" not available.');
+    Exit;
+  end;
+  LPlain := TConverters.ConvertStringToBytes('Secret message', TEncoding.UTF8);
+
+  LCipher.Init(True, AParams);
+  LBlockSize := LCipher.GetBlockSize();
+  System.SetLength(LCipherText, System.Length(LPlain) + LBlockSize);
+  LOutOff := 0;
+  LCount := LCipher.ProcessBytes(LPlain, 0, System.Length(LPlain), LCipherText, LOutOff);
+  System.Inc(LOutOff, LCount);
+  LCount := LCipher.DoFinal(LCipherText, LOutOff);
+  System.Inc(LOutOff, LCount);
+  System.SetLength(LCipherText, LOutOff);
+  Logger.LogInformation(Format('%s encrypted length: %d', [ACipherAlgorithm, System.Length(LCipherText)]));
+
+  LCipher.Init(False, AParams);
+  System.SetLength(LDecrypted, System.Length(LCipherText));
+  LOutOff := 0;
+  LCount := LCipher.ProcessBytes(LCipherText, 0, System.Length(LCipherText), LDecrypted, LOutOff);
+  System.Inc(LOutOff, LCount);
+  LCount := LCipher.DoFinal(LDecrypted, LOutOff);
+  System.Inc(LOutOff, LCount);
+  System.SetLength(LDecrypted, LOutOff);
+  if TArrayUtilities.AreEqual(LPlain, LDecrypted) then
+    Logger.LogInformation(ACipherAlgorithm + ' decrypt match: success.')
+  else
+    Logger.LogWarning(ACipherAlgorithm + ' decrypt match: failed.');
+end;
+
+function GetAesKeySizeLabel(AKeySizeBytes: Int32): string;
+begin
+  case AKeySizeBytes of
+    16: Result := 'AES-128';
+    24: Result := 'AES-192';
+    32: Result := 'AES-256';
+  else
+    raise EArgumentException.Create(Format('Invalid AES key size: %d bytes. Valid sizes are 16, 24, 32.', [AKeySizeBytes]));
+  end;
+end;
+
+procedure TCipherExample.RunAesEncryptDecrypt(const ACipherAlgorithm: string;
+  AKeySizeBytes: Int32);
+var
+  LKey, LIV: TBytes;
+  LSecureRandom: ISecureRandom;
+  LParams: ICipherParameters;
+  LKeyAlg: string;
+begin
+  Logger.LogInformation(Format('%s %s (%d-byte key)', [GetAesKeySizeLabel(AKeySizeBytes), ACipherAlgorithm, AKeySizeBytes]));
+  LSecureRandom := TSecureRandom.Create();
+  System.SetLength(LKey, AKeySizeBytes);
+  System.SetLength(LIV, 16);
+  LSecureRandom.NextBytes(LKey);
+  LSecureRandom.NextBytes(LIV);
+  LKeyAlg := GetKeyAlgorithmName(ACipherAlgorithm);
+  LParams := TParametersWithIV.Create(TParameterUtilities.CreateKeyParameter(LKeyAlg, LKey), LIV) as ICipherParameters;
+  RunCipherEncryptDecrypt(ACipherAlgorithm, LParams);
+end;
+
+procedure TCipherExample.Run;
+begin
+  Logger.LogInformation('--- Cipher example: encrypt/decrypt ---');
+  RunAesEncryptDecrypt('AES/CBC/PKCS7PADDING', 16);
+  RunAesEncryptDecrypt('AES/CBC/PKCS7PADDING', 24);
+  RunAesEncryptDecrypt('AES/CBC/PKCS7PADDING', 32);
+end;
+
+end.

CryptoLib.Examples/src/Examples/ClpDigestExample.pas

@@ -0,0 +1,221 @@
+unit ClpDigestExample;
+
+interface
+
+uses
+  SysUtils,
+  ClpIDigest,
+  ClpIMac,
+  ClpDigestUtilities,
+  ClpMacUtilities,
+  ClpEncoders,
+  ClpConverters,
+  ClpKeyParameter,
+  ClpPkcs5S2ParametersGenerator,
+  ClpIPkcs5S2ParametersGenerator,
+  ClpArgon2ParametersGenerator,
+  ClpIArgon2ParametersGenerator,
+  ClpScryptParametersGenerator,
+  ClpIScryptParametersGenerator,
+  ClpICipherParameters,
+  ClpIKeyParameter,
+  ClpCryptoLibTypes,
+  ClpExampleBase;
+
+type
+  TDigestExample = class(TExampleBase)
+  public
+    procedure Run; override;
+  private
+    procedure RunHash(const ADigestAlgorithm: string);
+    procedure RunHmac(const AHmacAlgorithm: string);
+    procedure RunPbkdf2(const ADigestAlgorithm: string);
+    procedure RunArgon2D;
+    procedure RunArgon2I;
+    procedure RunArgon2Id;
+    procedure RunScrypt;
+  end;
+
+implementation
+
+procedure TDigestExample.RunHash(const ADigestAlgorithm: string);
+var
+  LDigest: IDigest;
+  LInput, LHash: TBytes;
+begin
+  Logger.LogInformation('Digest: ' + ADigestAlgorithm);
+  LInput := TConverters.ConvertStringToBytes('Hello CryptoLib', TEncoding.UTF8);
+  LDigest := TDigestUtilities.GetDigest(ADigestAlgorithm);
+  if LDigest = nil then
+  begin
+    Logger.LogWarning('Digest "' + ADigestAlgorithm + '" not available.');
+    Exit;
+  end;
+  System.SetLength(LHash, LDigest.GetDigestSize);
+  LDigest.BlockUpdate(LInput, 0, System.Length(LInput));
+  LDigest.DoFinal(LHash, 0);
+  Logger.LogInformation(Format('Hash %s: %s', [ADigestAlgorithm, THexEncoder.Encode(LHash, False)]));
+end;
+
+procedure TDigestExample.RunHmac(const AHmacAlgorithm: string);
+var
+  LMac: IMac;
+  LKey, LMsg, LResult: TBytes;
+begin
+  Logger.LogInformation('HMAC: ' + AHmacAlgorithm);
+  LKey := TConverters.ConvertStringToBytes('secret-key', TEncoding.UTF8);
+  LMsg := TConverters.ConvertStringToBytes('message to authenticate', TEncoding.UTF8);
+  LMac := TMacUtilities.GetMac(AHmacAlgorithm);
+  if LMac = nil then
+  begin
+    Logger.LogWarning('HMAC "' + AHmacAlgorithm + '" not available.');
+    Exit;
+  end;
+  LMac.Init(TKeyParameter.Create(LKey) as IKeyParameter);
+  LMac.BlockUpdate(LMsg, 0, System.Length(LMsg));
+  LResult := LMac.DoFinal;
+  Logger.LogInformation(Format('%s: %s', [AHmacAlgorithm, THexEncoder.Encode(LResult, False)]));
+end;
+
+procedure TDigestExample.RunPbkdf2(const ADigestAlgorithm: string);
+var
+  LGen: IPkcs5S2ParametersGenerator;
+  LDigest: IDigest;
+  LPassword, LSalt: TBytes;
+  LParams: ICipherParameters;
+  LKey: IKeyParameter;
+  LDerived: TBytes;
+  LIters: Int32;
+begin
+  LIters := 10000;
+  Logger.LogInformation(Format('PBKDF2: digest %s, %d iterations', [ADigestAlgorithm, LIters]));
+  LPassword := TConverters.ConvertStringToBytes('password', TEncoding.UTF8);
+  LSalt := TConverters.ConvertStringToBytes('salt', TEncoding.UTF8);
+  LDigest := TDigestUtilities.GetDigest(ADigestAlgorithm);
+  if LDigest = nil then
+  begin
+    Logger.LogWarning('Digest "' + ADigestAlgorithm + '" not available for PBKDF2.');
+    Exit;
+  end;
+  LGen := TPkcs5S2ParametersGenerator.Create(LDigest) as IPkcs5S2ParametersGenerator;
+  LGen.Init(LPassword, LSalt, LIters);
+  LParams := LGen.GenerateDerivedParameters('AES', 256);
+  if Supports(LParams, IKeyParameter, LKey) then
+  begin
+    LDerived := LKey.GetKey();
+    Logger.LogInformation(Format('PBKDF2-HMAC-%s (%d iters) derived %d bytes: %s', [ADigestAlgorithm, LIters, System.Length(LDerived), THexEncoder.Encode(LDerived, False)]));
+  end
+  else
+    Logger.LogWarning('PBKDF2: could not get key parameter.');
+end;
+
+procedure TDigestExample.RunArgon2D;
+var
+  LGen: IArgon2ParametersGenerator;
+  LPassword, LSalt: TBytes;
+  LParams: ICipherParameters;
+  LKey: IKeyParameter;
+  LDerived: TBytes;
+begin
+  LPassword := TConverters.ConvertStringToBytes('password', TEncoding.UTF8);
+  LSalt := TConverters.ConvertStringToBytes('salt', TEncoding.UTF8);
+  LGen := TArgon2ParametersGenerator.Create() as IArgon2ParametersGenerator;
+  LGen.Init(TCryptoLibArgon2Type.Argon2D, TCryptoLibArgon2Version.Argon2Version13,
+    LPassword, LSalt, nil, nil, 2, 65536, 1, TCryptoLibArgon2MemoryCostType.MemoryAsKB);
+  LParams := LGen.GenerateDerivedParameters('AES', 256);
+  if Supports(LParams, IKeyParameter, LKey) then
+  begin
+    LDerived := LKey.GetKey();
+    Logger.LogInformation(Format('Argon2d (2 iters, 64 MiB, 1 lane) derived %d bytes: %s', [System.Length(LDerived), THexEncoder.Encode(LDerived, False)]));
+  end
+  else
+    Logger.LogWarning('Argon2d: could not get key parameter.');
+end;
+
+procedure TDigestExample.RunArgon2I;
+var
+  LGen: IArgon2ParametersGenerator;
+  LPassword, LSalt: TBytes;
+  LParams: ICipherParameters;
+  LKey: IKeyParameter;
+  LDerived: TBytes;
+begin
+  LPassword := TConverters.ConvertStringToBytes('password', TEncoding.UTF8);
+  LSalt := TConverters.ConvertStringToBytes('salt', TEncoding.UTF8);
+  LGen := TArgon2ParametersGenerator.Create() as IArgon2ParametersGenerator;
+  LGen.Init(TCryptoLibArgon2Type.Argon2I, TCryptoLibArgon2Version.Argon2Version13,
+    LPassword, LSalt, nil, nil, 2, 65536, 1, TCryptoLibArgon2MemoryCostType.MemoryAsKB);
+  LParams := LGen.GenerateDerivedParameters('AES', 256);
+  if Supports(LParams, IKeyParameter, LKey) then
+  begin
+    LDerived := LKey.GetKey();
+    Logger.LogInformation(Format('Argon2i (2 iters, 64 MiB, 1 lane) derived %d bytes: %s', [System.Length(LDerived), THexEncoder.Encode(LDerived, False)]));
+  end
+  else
+    Logger.LogWarning('Argon2i: could not get key parameter.');
+end;
+
+procedure TDigestExample.RunArgon2Id;
+var
+  LGen: IArgon2ParametersGenerator;
+  LPassword, LSalt: TBytes;
+  LParams: ICipherParameters;
+  LKey: IKeyParameter;
+  LDerived: TBytes;
+begin
+  LPassword := TConverters.ConvertStringToBytes('password', TEncoding.UTF8);
+  LSalt := TConverters.ConvertStringToBytes('salt', TEncoding.UTF8);
+  LGen := TArgon2ParametersGenerator.Create() as IArgon2ParametersGenerator;
+  LGen.Init(TCryptoLibArgon2Type.Argon2ID, TCryptoLibArgon2Version.Argon2Version13,
+    LPassword, LSalt, nil, nil, 2, 65536, 1, TCryptoLibArgon2MemoryCostType.MemoryAsKB);
+  LParams := LGen.GenerateDerivedParameters('AES', 256);
+  if Supports(LParams, IKeyParameter, LKey) then
+  begin
+    LDerived := LKey.GetKey();
+    Logger.LogInformation(Format('Argon2id (2 iters, 64 MiB, 1 lane) derived %d bytes: %s', [System.Length(LDerived), THexEncoder.Encode(LDerived, False)]));
+  end
+  else
+    Logger.LogWarning('Argon2id: could not get key parameter.');
+end;
+
+procedure TDigestExample.RunScrypt;
+var
+  LGen: IScryptParametersGenerator;
+  LPassword, LSalt: TBytes;
+  LParams: ICipherParameters;
+  LKey: IKeyParameter;
+  LDerived: TBytes;
+begin
+  LPassword := TConverters.ConvertStringToBytes('password', TEncoding.UTF8);
+  LSalt := TConverters.ConvertStringToBytes('salt', TEncoding.UTF8);
+  LGen := TScryptParametersGenerator.Create() as IScryptParametersGenerator;
+  LGen.Init(LPassword, LSalt, 16384, 8, 1);
+  LParams := LGen.GenerateDerivedParameters('AES', 256);
+  if Supports(LParams, IKeyParameter, LKey) then
+  begin
+    LDerived := LKey.GetKey();
+    Logger.LogInformation(Format('Scrypt (N=16384, r=8, p=1) derived %d bytes: %s', [System.Length(LDerived), THexEncoder.Encode(LDerived, False)]));
+  end
+  else
+    Logger.LogWarning('Scrypt: could not get key parameter.');
+end;
+
+procedure TDigestExample.Run;
+begin
+  Logger.LogInformation('--- Digest example: Hash ---');
+  RunHash('SHA-256');
+  Logger.LogInformation('--- Digest example: HMAC ---');
+  RunHmac('HMAC-SHA256');
+  Logger.LogInformation('--- Digest example: Key derivation (PBKDF2) ---');
+  RunPbkdf2('SHA-256');
+  Logger.LogInformation('--- Digest example: Key derivation (Argon2d) ---');
+  RunArgon2D;
+  Logger.LogInformation('--- Digest example: Key derivation (Argon2i) ---');
+  RunArgon2I;
+  Logger.LogInformation('--- Digest example: Key derivation (Argon2id) ---');
+  RunArgon2Id;
+  Logger.LogInformation('--- Digest example: Key derivation (Scrypt) ---');
+  RunScrypt;
+end;
+
+end.

CryptoLib.Examples/src/Examples/ClpEcExample.pas

@@ -0,0 +1,182 @@
+unit ClpEcExample;
+
+interface
+
+uses
+  SysUtils,
+  ClpECUtilities,
+  ClpIX9ECParametersHolder,
+  ClpIAsn1Objects,
+  ClpSecureRandom,
+  ClpBigInteger,
+  ClpECParameters,
+  ClpIECParameters,
+  ClpECGenerators,
+  ClpIECGenerators,
+  ClpSignerUtilities,
+  ClpEncoders,
+  ClpConverters,
+  ClpIAsymmetricCipherKeyPair,
+  ClpIX9ECAsn1Objects,
+  ClpIECCommon,
+  ClpISecureRandom,
+  ClpISigner,
+  ClpExampleBase;
+
+type
+  TEcExample = class(TExampleBase)
+  private
+    procedure RunEcdsaSignVerify(const ACurveName: string;
+      const ASignatureAlgorithm: string);
+    procedure RunKeyRecreateFromBytes(const ACurveName: string);
+    procedure RunPublicKeyFromXY(const ACurveName: string);
+
+    function GetCurveByName(const ACurveName: string): IX9ECParameters;
+  public
+    procedure Run; override;
+  end;
+
+implementation
+
+function TEcExample.GetCurveByName(const ACurveName: string): IX9ECParameters;
+begin
+  Result := TECUtilities.FindECCurveByName(ACurveName);
+end;
+
+procedure TEcExample.RunEcdsaSignVerify(const ACurveName: string;
+  const ASignatureAlgorithm: string);
+var
+  LCurve: IX9ECParameters;
+  LDomain: IECDomainParameters;
+  LGen: IECKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LSigner: ISigner;
+  LMsg, LSig: TBytes;
+begin
+  LCurve := GetCurveByName(ACurveName);
+  if LCurve = nil then
+  begin
+    Logger.LogWarning('Curve "' + ACurveName + '" not found.');
+    Exit;
+  end;
+  Logger.LogInformation('Curve: ' + ACurveName + ', Algorithm: ' + ASignatureAlgorithm);
+  LDomain := TECDomainParameters.Create(LCurve.Curve, LCurve.G, LCurve.N, LCurve.H, LCurve.GetSeed);
+  LGen := TECKeyPairGenerator.Create('ECDSA') as IECKeyPairGenerator;
+  LGen.Init(TECKeyGenerationParameters.Create(LDomain, TSecureRandom.Create() as ISecureRandom) as IECKeyGenerationParameters);
+  LKp := LGen.GenerateKeyPair();
+  LSigner := TSignerUtilities.GetSigner(ASignatureAlgorithm);
+  if LSigner = nil then
+  begin
+    Logger.LogWarning('Signer "' + ASignatureAlgorithm + '" not available.');
+    Exit;
+  end;
+  LMsg := TConverters.ConvertStringToBytes('PascalECDSA', TEncoding.UTF8);
+  LSigner.Init(True, LKp.Private);
+  LSigner.BlockUpdate(LMsg, 0, System.Length(LMsg));
+  LSig := LSigner.GenerateSignature();
+  Logger.LogInformation(ASignatureAlgorithm + ' signature (hex): ' + THexEncoder.Encode(LSig, False));
+  LSigner.Init(False, LKp.Public);
+  LSigner.BlockUpdate(LMsg, 0, System.Length(LMsg));
+  if LSigner.VerifySignature(LSig) then
+    Logger.LogInformation(ASignatureAlgorithm + ' verification passed.')
+  else
+    Logger.LogWarning(ASignatureAlgorithm + ' verification failed.');
+end;
+
+procedure TEcExample.RunKeyRecreateFromBytes(const ACurveName: string);
+var
+  LCurve: IX9ECParameters;
+  LDomain: IECDomainParameters;
+  LGen: IECKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LPriv: IECPrivateKeyParameters;
+  LPub: IECPublicKeyParameters;
+  LPubBytes, LPrivBytes: TBytes;
+  LRegenPub: IECPublicKeyParameters;
+  LRegenPriv: IECPrivateKeyParameters;
+  LD: TBigInteger;
+begin
+  LCurve := GetCurveByName(ACurveName);
+  if LCurve = nil then
+  begin
+    Logger.LogWarning('Curve "' + ACurveName + '" not found.');
+    Exit;
+  end;
+  Logger.LogInformation('Curve: ' + ACurveName);
+  LDomain := TECDomainParameters.Create(LCurve.Curve, LCurve.G, LCurve.N, LCurve.H, LCurve.GetSeed);
+  LGen := TECKeyPairGenerator.Create('ECDSA') as IECKeyPairGenerator;
+  LGen.Init(TECKeyGenerationParameters.Create(LDomain, TSecureRandom.Create() as ISecureRandom) as IECKeyGenerationParameters);
+  LKp := LGen.GenerateKeyPair();
+  if not Supports(LKp.Private, IECPrivateKeyParameters, LPriv) or not Supports(LKp.Public, IECPublicKeyParameters, LPub) then
+  begin
+    Logger.LogError('EC key pair type mismatch.');
+    Exit;
+  end;
+  LPubBytes := LPub.Q.GetEncoded();
+  LPrivBytes := LPriv.D.ToByteArray();
+  LRegenPub := TECPublicKeyParameters.Create('ECDSA', LCurve.Curve.DecodePoint(LPubBytes), LDomain) as IECPublicKeyParameters;
+  LD := TBigInteger.Create(1, LPrivBytes);
+  LRegenPriv := TECPrivateKeyParameters.Create('ECDSA', LD, LDomain) as IECPrivateKeyParameters;
+  if LPub.Equals(LRegenPub) then
+    Logger.LogInformation('Public key recreation: match.')
+  else
+    Logger.LogWarning('Public key recreation: mismatch.');
+  if LPriv.Equals(LRegenPriv) then
+    Logger.LogInformation('Private key recreation: match.')
+  else
+    Logger.LogWarning('Private key recreation: mismatch.');
+end;
+
+procedure TEcExample.RunPublicKeyFromXY(const ACurveName: string);
+var
+  LCurve: IX9ECParameters;
+  LDomain: IECDomainParameters;
+  LGen: IECKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LPub: IECPublicKeyParameters;
+  LXBytes, LYBytes: TBytes;
+  LBigX, LBigY: TBigInteger;
+  LPoint: IECPoint;
+  LRegenPub: IECPublicKeyParameters;
+begin
+  LCurve := GetCurveByName(ACurveName);
+  if LCurve = nil then
+  begin
+    Logger.LogWarning('Curve "' + ACurveName + '" not found.');
+    Exit;
+  end;
+  Logger.LogInformation('Curve: ' + ACurveName);
+  LDomain := TECDomainParameters.Create(LCurve.Curve, LCurve.G, LCurve.N, LCurve.H, LCurve.GetSeed);
+  LGen := TECKeyPairGenerator.Create('ECDSA') as IECKeyPairGenerator;
+  LGen.Init(TECKeyGenerationParameters.Create(LDomain, TSecureRandom.Create() as ISecureRandom) as IECKeyGenerationParameters);
+  LKp := LGen.GenerateKeyPair();
+  if not Supports(LKp.Public, IECPublicKeyParameters, LPub) then
+  begin
+    Logger.LogError('EC public key type mismatch.');
+    Exit;
+  end;
+  LXBytes := LPub.Q.Normalize.AffineXCoord.ToBigInteger.ToByteArray();
+  LYBytes := LPub.Q.Normalize.AffineYCoord.ToBigInteger.ToByteArray();
+  LBigX := TBigInteger.Create(1, LXBytes);
+  LBigY := TBigInteger.Create(1, LYBytes);
+  LPoint := LCurve.Curve.CreatePoint(LBigX, LBigY);
+  LRegenPub := TECPublicKeyParameters.Create(LPoint, LDomain) as IECPublicKeyParameters;
+  if LPub.Equals(LRegenPub) then
+    Logger.LogInformation('Public key from X/Y recreation: match.')
+  else
+    Logger.LogWarning('Public key from X/Y recreation: mismatch.');
+end;
+
+procedure TEcExample.Run;
+begin
+  Logger.LogInformation('--- EC example: ECDSA sign/verify ---');
+  RunEcdsaSignVerify('secp256k1', 'SHA-256withECDSA');
+
+  Logger.LogInformation('--- EC example: Key recreate from bytes ---');
+  RunKeyRecreateFromBytes('secp256k1');
+
+  Logger.LogInformation('--- EC example: Public key from X/Y ---');
+  RunPublicKeyFromXY('secp256k1');
+end;
+
+end.

CryptoLib.Examples/src/Examples/ClpRsaExample.pas

@@ -0,0 +1,69 @@
+unit ClpRsaExample;
+
+interface
+
+uses
+  SysUtils,
+  ClpGeneratorUtilities,
+  ClpSecureRandom,
+  ClpBigInteger,
+  ClpRsaParameters,
+  ClpIRsaParameters,
+  ClpSignerUtilities,
+  ClpEncoders,
+  ClpConverters,
+  ClpIAsymmetricCipherKeyPair,
+  ClpIAsymmetricCipherKeyPairGenerator,
+  ClpISecureRandom,
+  ClpISigner,
+  ClpExampleBase;
+
+type
+  TRsaExample = class(TExampleBase)
+  private
+    procedure RunRsaSignVerify(const ASignatureAlgorithm: string);
+  public
+    procedure Run; override;
+  end;
+
+implementation
+
+procedure TRsaExample.RunRsaSignVerify(const ASignatureAlgorithm: string);
+var
+  LKpg: IAsymmetricCipherKeyPairGenerator;
+  LKp: IAsymmetricCipherKeyPair;
+  LSigner: ISigner;
+  LMsg, LSig: TBytes;
+begin
+  Logger.LogInformation('Algorithm: ' + ASignatureAlgorithm);
+  LKpg := TGeneratorUtilities.GetKeyPairGenerator('RSA');
+  LKpg.Init(TRsaKeyGenerationParameters.Create(TBigInteger.ValueOf(65537),
+    TSecureRandom.Create() as ISecureRandom, 2048, 25) as IRsaKeyGenerationParameters);
+  LKp := LKpg.GenerateKeyPair();
+  LSigner := TSignerUtilities.GetSigner(ASignatureAlgorithm);
+  if LSigner = nil then
+  begin
+    Logger.LogWarning('Signer "' + ASignatureAlgorithm + '" not available.');
+    Exit;
+  end;
+  LMsg := TConverters.ConvertStringToBytes('Message to sign', TEncoding.UTF8);
+  LSigner.Init(True, LKp.Private);
+  LSigner.BlockUpdate(LMsg, 0, System.Length(LMsg));
+  LSig := LSigner.GenerateSignature();
+  Logger.LogInformation(ASignatureAlgorithm + ' signature (hex): ' + THexEncoder.Encode(LSig, False));
+  LSigner.Init(False, LKp.Public);
+  LSigner.BlockUpdate(LMsg, 0, System.Length(LMsg));
+  if LSigner.VerifySignature(LSig) then
+    Logger.LogInformation(ASignatureAlgorithm + ' verification passed.')
+  else
+    Logger.LogWarning(ASignatureAlgorithm + ' verification failed.');
+end;
+
+procedure TRsaExample.Run;
+begin
+  Logger.LogInformation('--- RSA example: Sign and verify ---');
+  RunRsaSignVerify('SHA-256withRSA');
+  RunRsaSignVerify('SHA256WITHRSAANDMGF1');
+end;
+
+end.

CryptoLib/src/Crypto/Parameters/ClpECParameters.pas

@@ -24,6 +24,7 @@ interface
 uses
   SyncObjs,
   SysUtils,
+  Generics.Collections,
   ClpBigInteger,
   ClpECAlgorithms,
   ClpIECCommon,
@@ -35,6 +36,7 @@ uses
   ClpKeyGenerationParameters,
   ClpISecureRandom,
   ClpECUtilities,
+  ClpCryptoLibComparers,
   ClpCryptoLibTypes;
 
 resourcestring
@@ -52,6 +54,7 @@ resourcestring
   SAlgorithmNil = 'Algorithm Cannot be Empty';
   SParameterNil = 'Parameter Cannot be Nil';
   SUnRecognizedAlgorithm = 'Unrecognised Algorithm: " %s, "Algorithm';
+  SNameNotValidParameterSet = 'Name is not a valid public key parameter set';
 
 type
   TECDomainParameters = class(TInterfacedObject, IECDomainParameters)
@@ -81,6 +84,16 @@ type
 
     class function FromX9ECParameters(const AX9ECParameters: IX9ECParameters): IECDomainParameters; static;
     class function FromX962Parameters(const AX962Parameters: IX962Parameters): IECDomainParameters; static;
+    /// <summary>
+    /// Look up domain parameters by curve name. When the curve has a known OID,
+    /// returns named domain parameters (so SubjectPublicKeyInfo uses the curve OID).
+    /// Otherwise returns parameters from X9ECParameters (explicit encoding).
+    /// </summary>
+    class function LookupName(const AName: String): IECDomainParameters; static;
+    /// <summary>
+    /// Copy domain parameters from another instance.
+    /// </summary>
+    class function FromDomainParameters(const AOther: IECDomainParameters): IECDomainParameters; static;
 
     constructor Create(const ACurve: IECCurve; const AG: IECPoint;
       const AN: TBigInteger); overload;
@@ -135,32 +148,38 @@ type
 
   strict private
 
-  const
-
-    FAlgorithms: array [0 .. 5] of String = ('EC', 'ECDSA', 'ECDH', 'ECDHC', 'ECGOST3410', 'ECMQV');
+  class var
+    FAlgorithms: TDictionary<String, String>;
 
   var
     FAlgorithm: String;
     FParameters: IECDomainParameters;
 
   strict protected
+    class constructor Create;
+    class destructor Destroy;
 
     constructor Create(const AAlgorithm: String; AIsPrivate: Boolean;
-      const AParameters: IECDomainParameters);
+      const AParameters: IECDomainParameters); overload;
 
     function CreateKeyGenerationParameters(const ARandom: ISecureRandom)
       : IECKeyGenerationParameters; inline;
 
     function GetAlgorithmName: String; inline;
     function GetParameters: IECDomainParameters; inline;
+    function GetPublicKeyParamSet: IDerObjectIdentifier;
 
     function Equals(const AOther: IECKeyParameters): Boolean;
       reintroduce; overload;
 
   public
+    constructor Create(const AAlgorithm: String; AIsPrivate: Boolean;
+      const APublicKeyParamSet: IDerObjectIdentifier); overload;
+
     class function VerifyAlgorithmName(const AAlgorithm: String): String; static;
     property AlgorithmName: String read GetAlgorithmName;
     property Parameters: IECDomainParameters read GetParameters;
+    property PublicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -182,6 +201,9 @@ type
     constructor Create(const AAlgorithm: String; const AQ: IECPoint;
       const AParameters: IECDomainParameters); overload;
 
+    constructor Create(const AAlgorithm: String; const AQ: IECPoint;
+      const APublicKeyParamSet: IDerObjectIdentifier); overload;
+
     property Q: IECPoint read GetQ;
 
     function Equals(const AOther: IECPublicKeyParameters): Boolean;
@@ -207,6 +229,9 @@ type
     constructor Create(const AAlgorithm: String; const AD: TBigInteger;
       const AParameters: IECDomainParameters); overload;
 
+    constructor Create(const AAlgorithm: String; const AD: TBigInteger;
+      const APublicKeyParamSet: IDerObjectIdentifier); overload;
+
     property D: TBigInteger read GetD;
 
     function Equals(const AOther: IECPrivateKeyParameters): Boolean;
@@ -227,8 +252,15 @@ type
 
   public
     constructor Create(const ADomainParameters: IECDomainParameters;
-      const ARandom: ISecureRandom);
+      const ARandom: ISecureRandom); overload;
+
+    constructor Create(const APublicKeyParamSet: IDerObjectIdentifier;
+      const ARandom: ISecureRandom); overload;
+
+    function GetPublicKeyParamSet: IDerObjectIdentifier;
+
     property DomainParameters: IECDomainParameters read GetDomainParameters;
+    property PublicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
   end;
 
 implementation
@@ -275,6 +307,37 @@ begin
   Result := FromX9ECParameters(LX9);
 end;
 
+class function TECDomainParameters.LookupName(const AName: String): IECDomainParameters;
+var
+  LOid: IDerObjectIdentifier;
+  LX9: IX9ECParameters;
+begin
+  if AName = '' then
+    raise EArgumentNilCryptoLibException.CreateRes(@SParameterNil);
+  LOid := TECUtilities.FindECCurveOid(AName);
+  if LOid <> nil then
+  begin
+    Result := TECNamedDomainParameters.LookupOid(LOid);
+    Exit;
+  end;
+  LX9 := TECUtilities.FindECCurveByName(AName);
+  if LX9 = nil then
+    raise EArgumentCryptoLibException.CreateRes(@SNameNotValidParameterSet);
+  Result := FromX9ECParameters(LX9);
+end;
+
+class function TECDomainParameters.FromDomainParameters(const AOther: IECDomainParameters): IECDomainParameters;
+var
+  LNamed: IECNamedDomainParameters;
+begin
+  if AOther = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SParameterNil);
+  if Supports(AOther, IECNamedDomainParameters, LNamed) then
+    Result := TECNamedDomainParameters.Create(LNamed.Name, AOther)
+  else
+    Result := TECDomainParameters.Create(AOther.Curve, AOther.G, AOther.N, AOther.H, AOther.Seed);
+end;
+
 function TECDomainParameters.GetCurve: IECCurve;
 begin
   Result := FCurve;
@@ -393,11 +456,6 @@ begin
 
   Result := Curve.Equals(AOther.Curve) and G.Equals(AOther.G) and
     N.Equals(AOther.N);
-
-  if H.IsInitialized then
-  begin
-    Result := Result and H.Equals(AOther.H);
-  end;
 end;
 
 function TECDomainParameters.GetHashCode: {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
@@ -410,12 +468,6 @@ begin
   Result := Result xor FG.GetHashCode();
   Result := Result * 257;
   Result := Result xor Fn.GetHashCode();
-
-  if H.IsInitialized then
-  begin
-    Result := Result * 257;
-    Result := Result xor FH.GetHashCode();
-  end;
 end;
 
 function TECDomainParameters.ToX962Parameters: IX962Parameters;
@@ -490,6 +542,22 @@ end;
 
 { TECKeyParameters }
 
+class constructor TECKeyParameters.Create;
+begin
+  FAlgorithms := TDictionary<String, String>.Create(TCryptoLibComparers.OrdinalIgnoreCaseEqualityComparer);
+  FAlgorithms.Add('EC', 'EC');
+  FAlgorithms.Add('ECDSA', 'ECDSA');
+  FAlgorithms.Add('ECDH', 'ECDH');
+  FAlgorithms.Add('ECDHC', 'ECDHC');
+  FAlgorithms.Add('ECGOST3410', 'ECGOST3410');
+  FAlgorithms.Add('ECMQV', 'ECMQV');
+end;
+
+class destructor TECKeyParameters.Destroy;
+begin
+  FAlgorithms.Free;
+end;
+
 function TECKeyParameters.GetParameters: IECDomainParameters;
 begin
   Result := FParameters;
@@ -499,25 +567,10 @@ class function TECKeyParameters.VerifyAlgorithmName(const AAlgorithm
   : String): String;
 var
   LUpper: String;
-  LI: Int32;
-  LFound: Boolean;
 begin
-  LUpper := UpperCase(AAlgorithm);
-  LFound := False;
-  for LI := System.Low(FAlgorithms) to System.High(FAlgorithms) do
-  begin
-    if (FAlgorithms[LI] = AAlgorithm) then
-    begin
-      LFound := True;
-      break;
-    end;
-  end;
-
-  if (not LFound) then
-  begin
+  if (not FAlgorithms.TryGetValue(AAlgorithm, LUpper)) then
     raise EArgumentCryptoLibException.CreateResFmt(@SUnRecognizedAlgorithm,
       [AAlgorithm]);
-  end;
   Result := LUpper;
 end;
 
@@ -535,6 +588,22 @@ begin
   FParameters := AParameters;
 end;
 
+constructor TECKeyParameters.Create(const AAlgorithm: String; AIsPrivate: Boolean;
+  const APublicKeyParamSet: IDerObjectIdentifier);
+begin
+  Create(AAlgorithm, AIsPrivate, TECNamedDomainParameters.LookupOid(APublicKeyParamSet));
+end;
+
+function TECKeyParameters.GetPublicKeyParamSet: IDerObjectIdentifier;
+var
+  LNamed: IECNamedDomainParameters;
+begin
+  if Supports(FParameters, IECNamedDomainParameters, LNamed) then
+    Result := LNamed.Name
+  else
+    Result := nil;
+end;
+
 function TECKeyParameters.CreateKeyGenerationParameters
   (const ARandom: ISecureRandom): IECKeyGenerationParameters;
 begin
@@ -594,6 +663,15 @@ begin
   Create('EC', AQ, AParameters);
 end;
 
+constructor TECPublicKeyParameters.Create(const AAlgorithm: String;
+  const AQ: IECPoint; const APublicKeyParamSet: IDerObjectIdentifier);
+begin
+  inherited Create(AAlgorithm, False, APublicKeyParamSet);
+  if (AQ = nil) then
+    raise EArgumentNilCryptoLibException.CreateRes(@SQNil);
+  FQ := Parameters.ValidatePublicPoint(AQ);
+end;
+
 function TECPublicKeyParameters.Equals(const AOther
   : IECPublicKeyParameters): Boolean;
 begin
@@ -640,6 +718,16 @@ begin
   FD := AParameters.ValidatePrivateScalar(AD);
 end;
 
+constructor TECPrivateKeyParameters.Create(const AAlgorithm: String;
+  const AD: TBigInteger; const APublicKeyParamSet: IDerObjectIdentifier);
+begin
+  inherited Create(AAlgorithm, True, APublicKeyParamSet);
+  if (not(AD.IsInitialized)) then
+    raise EArgumentNilCryptoLibException.CreateResFmt
+      (@SBigIntegerNotInitialized, ['d']);
+  FD := Parameters.ValidatePrivateScalar(AD);
+end;
+
 function TECPrivateKeyParameters.Equals(const AOther
   : IECPrivateKeyParameters): Boolean;
 begin
@@ -672,9 +760,25 @@ begin
   FDomainParams := ADomainParameters;
 end;
 
+constructor TECKeyGenerationParameters.Create(const APublicKeyParamSet: IDerObjectIdentifier;
+  const ARandom: ISecureRandom);
+begin
+  Create(TECNamedDomainParameters.LookupOid(APublicKeyParamSet), ARandom);
+end;
+
 function TECKeyGenerationParameters.GetDomainParameters: IECDomainParameters;
 begin
   Result := FDomainParams;
 end;
 
+function TECKeyGenerationParameters.GetPublicKeyParamSet: IDerObjectIdentifier;
+var
+  LNamed: IECNamedDomainParameters;
+begin
+  if Supports(FDomainParams, IECNamedDomainParameters, LNamed) then
+    Result := LNamed.Name
+  else
+    Result := nil;
+end;
+
 end.

CryptoLib/src/Interfaces/Crypto/Parameters/ClpIECParameters.pas

@@ -71,11 +71,13 @@ type
 
     function GetAlgorithmName: String;
     function GetParameters: IECDomainParameters;
+    function GetPublicKeyParamSet: IDerObjectIdentifier;
 
     function Equals(const AOther: IECKeyParameters): Boolean; overload;
 
     property AlgorithmName: String read GetAlgorithmName;
     property Parameters: IECDomainParameters read GetParameters;
+    property PublicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
 
   end;
 
@@ -99,7 +101,10 @@ type
     ['{B9343CA3-9274-4812-9FFC-2CC27486261E}']
 
     function GetDomainParameters: IECDomainParameters;
+    function GetPublicKeyParamSet: IDerObjectIdentifier;
+
     property DomainParameters: IECDomainParameters read GetDomainParameters;
+    property PublicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
   end;
 
 implementation