refactor some X9 EC Objects

CryptoLib.Tests/Delphi.Tests/CryptoLib.Tests.dpr

@@ -348,8 +348,7 @@ uses
   ClpIX509NameEntryConverter in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509NameEntryConverter.pas',
   ClpIX509NameTokenizer in '..\..\CryptoLib\src\Interfaces\Asn1\X509\ClpIX509NameTokenizer.pas',
   ClpIX9Asn1Objects in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9Asn1Objects.pas',
-  ClpIX9ECC in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9ECC.pas',
-  ClpIX9ECParameters in '..\..\CryptoLib\src\Interfaces\Asn1\X9\ClpIX9ECParameters.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',
@@ -466,8 +465,7 @@ uses
   ClpIX509V2AttributeCertificate in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509V2AttributeCertificate.pas',
   ClpX931Signer in '..\..\CryptoLib\src\Crypto\Signers\ClpX931Signer.pas',
   ClpX9Asn1Objects in '..\..\CryptoLib\src\Asn1\X9\ClpX9Asn1Objects.pas',
-  ClpX9ECC in '..\..\CryptoLib\src\Asn1\X9\ClpX9ECC.pas',
-  ClpX9ECParameters in '..\..\CryptoLib\src\Asn1\X9\ClpX9ECParameters.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',
@@ -508,6 +506,7 @@ uses
   ClpIX509CertificateParser in '..\..\CryptoLib\src\Interfaces\X509\ClpIX509CertificateParser.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',
   ClpFixedSecureRandom in '..\src\Utils\ClpFixedSecureRandom.pas',
   ClpIFixedSecureRandom in '..\src\Utils\ClpIFixedSecureRandom.pas',
   ClpIShortenedDigest in '..\src\Utils\ClpIShortenedDigest.pas',

CryptoLib.Tests/src/Asn1/X509/DeltaCertificateTests.pas

@@ -58,7 +58,7 @@ uses
   ClpAsn1SignatureFactory,
   ClpIAsymmetricCipherKeyPairGenerator,
   ClpIAsymmetricCipherKeyPair,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpIECDomainParameters,
   ClpISignatureFactory,
   CryptoLibTestBase;

CryptoLib.Tests/src/Crypto/DeterministicDsaTests.pas

@@ -42,7 +42,7 @@ uses
   ClpHMacDsaKCalculator,
   ClpIHMacDsaKCalculator,
   ClpICipherParameters,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpIECPrivateKeyParameters,
   ClpECPrivateKeyParameters,
   ClpIDsaPrivateKeyParameters,

CryptoLib.Tests/src/Math/EC/Custom/Sec/SecP256R1FieldTests.pas

@@ -33,7 +33,7 @@ uses
 {$ENDIF FPC}
   ClpSecureRandom,
   ClpISecureRandom,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpSecObjectIdentifiers,
   ClpConverters,
   ClpCustomNamedCurves,

CryptoLib.Tests/src/Math/EC/Custom/Sec/SecP384R1FieldTests.pas

@@ -33,7 +33,7 @@ uses
 {$ENDIF FPC}
   ClpSecureRandom,
   ClpISecureRandom,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpSecObjectIdentifiers,
   ClpConverters,
   ClpCustomNamedCurves,

CryptoLib.Tests/src/Math/EC/FixedPointTests.pas

@@ -40,7 +40,7 @@ uses
   ClpMultipliers,
   ClpIMultipliers,
   ClpECAlgorithms,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpCryptoLibTypes,
   CryptoLibTestBase;
 

CryptoLib.Tests/src/Math/ECAlgorithmsTests.pas

@@ -43,8 +43,8 @@ uses
   ClpECNamedCurveTable,
   ClpCustomNamedCurves,
   ClpECAlgorithms,
-  ClpX9ECParameters,
-  ClpIX9ECParameters,
+  ClpX9ECAsn1Objects,
+  ClpIX9ECAsn1Objects,
   ClpCryptoLibTypes,
   CryptoLibTestBase;
 
@@ -115,7 +115,7 @@ begin
     begin
       c := curve.Configure().SetCoordinateSystem(coord).CreateCurve();
       point := c.ImportPoint(x9.G);
-      params := TX9ECParameters.Create(c, point, x9.N, x9.H);
+      params := TX9ECParameters.Create(c, TX9ECPoint.Create(point, False) as IX9ECPoint, x9.N, x9.H);
       x9s.Add(params);
     end;
   end;

CryptoLib.Tests/src/Math/ECNRTests.pas

@@ -49,7 +49,7 @@ uses
   ClpECKeyPairGenerator,
   ClpIECKeyPairGenerator,
   ClpISigner,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpIAsymmetricCipherKeyPair,
   ClpECNamedCurveTable,
   ClpParametersWithRandom,

CryptoLib.Tests/src/Math/ECPointTests.pas

@@ -44,12 +44,10 @@ uses
   ClpECAlgorithms,
   ClpECCompUtilities,
   ClpIFiniteField,
-  ClpIX9ECParameters,
-  ClpIX9ECC,
-  ClpX9ECC,
+  ClpIX9ECAsn1Objects,
   ClpECC,
   ClpIECC,
-  ClpX9ECParameters,
+  ClpX9ECAsn1Objects,
   CryptoLibTestBase;
 
 type

CryptoLib.Tests/src/Math/IESCipherTests.pas

@@ -56,7 +56,7 @@ uses
   ClpIPaddingModes,
   ClpKdf2BytesGenerator,
   ClpIKdf2BytesGenerator,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpSecNamedCurves,
   ClpIECDomainParameters,
   ClpECDomainParameters,

CryptoLib.Tests/src/Math/PascalCoinECIESTests.pas

@@ -48,7 +48,7 @@ uses
   ClpIPaddingModes,
   ClpIMac,
   ClpMacUtilities,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpConverters,
   CryptoLibTestBase;
 

CryptoLib.Tests/src/Others/ECTests.pas

@@ -34,7 +34,7 @@ uses
   ClpFixedSecureRandom,
   ClpSecureRandom,
   ClpISecureRandom,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpECDsaSigner,
   ClpIECDsaSigner,
   ClpIBasicAgreement,

CryptoLib.Tests/src/Others/NamedCurveTests.pas

@@ -38,7 +38,7 @@ uses
   ClpIBasicAgreement,
   ClpSecNamedCurves,
   ClpTeleTrusTNamedCurves,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpECDomainParameters,
   ClpECNamedCurveTable,
   ClpECGost3410NamedCurves,

CryptoLib/src/Asn1/Nist/ClpNistNamedCurves.pas

@@ -25,7 +25,7 @@ uses
   SysUtils,
   Generics.Collections,
   ClpCryptoLibComparers,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpSecNamedCurves,
   ClpCryptoLibTypes,
   ClpIAsn1Objects,

CryptoLib/src/Asn1/Sec/ClpSecNamedCurves.pas

@@ -34,14 +34,12 @@ uses
   ClpBigInteger,
   ClpECC,
   ClpIECC,
-  ClpX9ECC,
-  ClpIX9ECC,
   ClpIAsn1Objects,
   ClpGlvTypeBEndomorphism,
   ClpIScalarSplitParameters,
   ClpScalarSplitParameters,
-  ClpX9ECParameters,
-  ClpIX9ECParameters,
+  ClpX9ECAsn1Objects,
+  ClpIX9ECAsn1Objects,
   ClpX9ECParametersHolder,
   ClpIX9ECParametersHolder,
   ClpIGlvTypeBParameters;

CryptoLib/src/Asn1/TeleTrust/ClpTeleTrusTNamedCurves.pas

@@ -32,11 +32,9 @@ uses
   ClpECCompUtilities,
   ClpECC,
   ClpIECC,
-  ClpX9ECC,
-  ClpIX9ECC,
   ClpIAsn1Objects,
-  ClpX9ECParameters,
-  ClpIX9ECParameters,
+  ClpX9ECAsn1Objects,
+  ClpIX9ECAsn1Objects,
   ClpX9ECParametersHolder,
   ClpIX9ECParametersHolder;
 

CryptoLib/src/Asn1/X9/ClpECNamedCurveTable.pas

@@ -28,7 +28,7 @@ uses
   ClpNistNamedCurves,
   ClpTeleTrusTNamedCurves,
   ClpIAsn1Objects,
-  ClpIX9ECParameters;
+  ClpIX9ECAsn1Objects;
 
 type
   /// <summary>

CryptoLib/src/Asn1/X9/ClpX9Asn1Objects.pas

@@ -28,8 +28,8 @@ uses
   ClpAsn1Core,
   ClpIAsn1Core,
   ClpIX9Asn1Objects,
-  ClpIX9ECParameters,
-  ClpX9ECParameters,
+  ClpIX9ECAsn1Objects,
+  ClpX9ECAsn1Objects,
   ClpCryptoLibTypes,
   ClpAsn1Utilities;
 

CryptoLib/src/Asn1/X9/ClpX9ECAsn1Objects.pas

@@ -0,0 +1,887 @@
+{ *********************************************************************************** }
+{ *                              CryptoLib Library                                  * }
+{ *                Copyright (c) 2018 - 20XX Ugochukwu Mmaduekwe                    * }
+{ *                 Github Repository <https://github.com/Xor-el>                   * }
+
+{ *  Distributed under the MIT software license, see the accompanying file LICENSE  * }
+{ *          or visit http://www.opensource.org/licenses/mit-license.php.           * }
+
+{ *                              Acknowledgements:                                  * }
+{ *                                                                                 * }
+{ *      Thanks to Sphere 10 Software (http://www.sphere10.com/) for sponsoring     * }
+{ *                           development of this library                           * }
+
+{ * ******************************************************************************* * }
+
+(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
+
+unit ClpX9ECAsn1Objects;
+
+{$I ..\..\Include\CryptoLib.inc}
+
+interface
+
+uses
+  SysUtils,
+  SyncObjs,
+  ClpAsn1Objects,
+  ClpIAsn1Objects,
+  ClpAsn1Core,
+  ClpIAsn1Core,
+  ClpIX9ECAsn1Objects,
+  ClpBigInteger,
+  ClpIECC,
+  ClpECAlgorithms,
+  ClpX9ObjectIdentifiers,
+  ClpX9IntegerConverter,
+  ClpCryptoLibTypes,
+  ClpAsn1Utilities,
+  ClpIFiniteField,
+  ClpIPolynomialExtensionField,
+  ClpECC;
+
+resourcestring
+  SBadSequenceSize = 'Bad sequence size: %d';
+  SUnexpectedElementsInSequence = 'Unexpected elements in sequence';
+  SBadVersion = 'bad version in X9ECParameters';
+  SFieldIDNil = 'fieldID';
+  SSeqNil = 'seq';
+  SCurveNil = 'curve';
+  SFieldElementNil = 'f';
+  SCurveNotImplemented = 'This type of ECCurve is not implemented';
+  SCharacteristicTwoFieldNotImplemented = 'This CharacteristicTwoField representation is not implemented';
+  SUnsupportedCurveType = '''curve'' is of an unsupported type';
+  SOnlyTrinomialAndPentanomial = 'Only trinomial and pentomial curves are supported';
+  SInconsistentKValues = 'inconsistent k values';
+  SEncodingNil = 'encoding';
+  SOctetStringNil = 's';
+
+type
+  /// <summary>
+  /// ASN.1 def for Elliptic-Curve Field ID structure. See X9.62 for further details.
+  /// </summary>
+  TX9FieldID = class(TAsn1Encodable, IX9FieldID)
+
+  strict private
+  var
+    FFieldType: IDerObjectIdentifier;
+    FParameters: IAsn1Object;
+
+  strict protected
+    function GetFieldType: IDerObjectIdentifier;
+    function GetParameters: IAsn1Object;
+
+    constructor Create(const ASeq: IAsn1Sequence); overload;
+
+  public
+    /// <summary>
+    /// Parse a X9FieldID from an object.
+    /// </summary>
+    class function GetInstance(AObj: TObject): IX9FieldID; overload; static;
+    /// <summary>
+    /// Get instance from ASN.1 convertible.
+    /// </summary>
+    class function GetInstance(const AObj: IAsn1Convertible): IX9FieldID; overload; static;
+    /// <summary>
+    /// Parse a X9FieldID from DER-encoded bytes.
+    /// </summary>
+    class function GetInstance(const AEncoded: TCryptoLibByteArray): IX9FieldID; overload; static;
+    /// <summary>
+    /// Parse a X9FieldID from a tagged object.
+    /// </summary>
+    class function GetInstance(const AObj: IAsn1TaggedObject;
+      AExplicitly: Boolean): IX9FieldID; overload; static;
+    /// <summary>
+    /// Get optional X9FieldID.
+    /// </summary>
+    class function GetOptional(const AElement: IAsn1Encodable): IX9FieldID; static;
+    /// <summary>
+    /// Get tagged X9FieldID.
+    /// </summary>
+    class function GetTagged(const ATaggedObject: IAsn1TaggedObject;
+      ADeclaredExplicit: Boolean): IX9FieldID; static;
+
+    /// <summary>
+    /// Constructor for elliptic curves over prime fields.
+    /// </summary>
+    constructor Create(const APrimeP: TBigInteger); overload;
+    /// <summary>
+    /// Constructor for elliptic curves over binary fields (trinomial).
+    /// </summary>
+    constructor Create(AM, AK1: Int32); overload;
+    /// <summary>
+    /// Constructor for elliptic curves over binary fields (pentanomial).
+    /// </summary>
+    constructor Create(AM, AK1, AK2, AK3: Int32); overload;
+
+    function ToAsn1Object: IAsn1Object; override;
+
+    property FieldType: IDerObjectIdentifier read GetFieldType;
+    property Parameters: IAsn1Object read GetParameters;
+
+  end;
+
+  /// <summary>
+  /// Class for processing an ECFieldElement as a DER object.
+  /// </summary>
+  TX9FieldElement = class(TAsn1Encodable, IX9FieldElement)
+
+  strict private
+  var
+    FF: IECFieldElement;
+
+  strict protected
+    function GetValue: IECFieldElement;
+
+  public
+    constructor Create(const AF: IECFieldElement);
+
+    function ToAsn1Object: IAsn1Object; override;
+
+    property Value: IECFieldElement read GetValue;
+
+  end;
+
+  /// <summary>
+  /// ASN.1 def for Elliptic-Curve Curve structure. See X9.62 for further details.
+  /// </summary>
+  TX9Curve = class(TAsn1Encodable, IX9Curve)
+
+  strict private
+  var
+    FCurve: IECCurve;
+    FSeed: IDerBitString;
+    FFieldType: IDerObjectIdentifier;
+
+  strict protected
+    function GetCurve: IECCurve;
+    function GetSeed: IDerBitString;
+    function GetSeedBytes: TCryptoLibByteArray;
+
+  public
+    constructor Create(const ACurve: IECCurve); overload;
+    constructor Create(const ACurve: IECCurve; const ASeed: TCryptoLibByteArray); overload;
+    constructor Create(const ACurve: IECCurve; const ASeed: IDerBitString); overload;
+    constructor Create(const AFieldID: IX9FieldID; const AOrder, ACofactor: TBigInteger;
+      const ASeq: IAsn1Sequence); overload;
+
+    function ToAsn1Object: IAsn1Object; override;
+
+    property Curve: IECCurve read GetCurve;
+    property Seed: IDerBitString read GetSeed;
+
+  end;
+
+  /// <summary>
+  /// class for describing an ECPoint as a Der object.
+  /// </summary>
+  TX9ECPoint = class(TAsn1Encodable, IX9ECPoint)
+
+  strict private
+  var
+    FEncoding: IAsn1OctetString;
+    FC: IECCurve;
+    FP: IECPoint;
+    FLock: TCriticalSection;
+
+  strict protected
+    function GetPoint: IECPoint;
+    function GetPointEncoding: IAsn1OctetString;
+    function GetIsPointCompressed: Boolean;
+
+    function CreatePoint: IECPoint;
+
+  public
+    constructor Create(const AP: IECPoint; ACompressed: Boolean); overload;
+    constructor Create(const AC: IECCurve; const AEncoding: TCryptoLibByteArray); overload;
+    constructor Create(const AC: IECCurve; const &AS: IAsn1OctetString); overload;
+
+    destructor Destroy; override;
+
+    function ToAsn1Object: IAsn1Object; override;
+
+    property Point: IECPoint read GetPoint;
+    property PointEncoding: IAsn1OctetString read GetPointEncoding;
+    property IsPointCompressed: Boolean read GetIsPointCompressed;
+
+  end;
+
+  /// <summary>
+  /// ASN.1 definition for Elliptic-Curve ECParameters structure. See X9.62 for further details.
+  /// </summary>
+  TX9ECParameters = class(TAsn1Encodable, IX9ECParameters)
+
+  strict private
+  var
+    FFieldID: IX9FieldID;
+    FCurve: IX9Curve;
+    FG: IX9ECPoint;
+    FN: TBigInteger;
+    FH: TBigInteger;
+
+  strict protected
+    function GetCurve: IECCurve;
+    function GetG: IECPoint;
+    function GetN: TBigInteger;
+    function GetH: TBigInteger;
+    function GetCurveEntry: IX9Curve;
+    function GetFieldIDEntry: IX9FieldID;
+    function GetBaseEntry: IX9ECPoint;
+
+    constructor Create(const ASeq: IAsn1Sequence); overload; deprecated 'Use GetInstance instead';
+
+  public
+    /// <summary>
+    /// Parse a X9ECParameters from an object.
+    /// </summary>
+    class function GetInstance(AObj: TObject): IX9ECParameters; overload; static;
+    /// <summary>
+    /// Get instance from ASN.1 convertible.
+    /// </summary>
+    class function GetInstance(const AObj: IAsn1Convertible): IX9ECParameters; overload; static;
+    /// <summary>
+    /// Parse a X9ECParameters from DER-encoded bytes.
+    /// </summary>
+    class function GetInstance(const AEncoded: TCryptoLibByteArray): IX9ECParameters; overload; static;
+    /// <summary>
+    /// Parse a X9ECParameters from a tagged object.
+    /// </summary>
+    class function GetInstance(const AObj: IAsn1TaggedObject; AExplicitly: Boolean): IX9ECParameters; overload; static;
+    /// <summary>
+    /// Get optional X9ECParameters.
+    /// </summary>
+    class function GetOptional(const AElement: IAsn1Encodable): IX9ECParameters; static;
+    /// <summary>
+    /// Get tagged X9ECParameters.
+    /// </summary>
+    class function GetTagged(const ATaggedObject: IAsn1TaggedObject; ADeclaredExplicit: Boolean): IX9ECParameters; static;
+
+    constructor Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+      const AN: TBigInteger); overload;
+    constructor Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+      const AN, AH: TBigInteger); overload;
+    constructor Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+      const AN, AH: TBigInteger; const ASeed: TCryptoLibByteArray); overload;
+    constructor Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+      const AN, AH: TBigInteger; const ASeed: IDerBitString); overload;
+
+    function GetSeed: TCryptoLibByteArray;
+
+    function ToAsn1Object: IAsn1Object; override;
+
+    property Curve: IECCurve read GetCurve;
+    property G: IECPoint read GetG;
+    property N: TBigInteger read GetN;
+    property H: TBigInteger read GetH;
+    property CurveEntry: IX9Curve read GetCurveEntry;
+    property FieldIDEntry: IX9FieldID read GetFieldIDEntry;
+    property BaseEntry: IX9ECPoint read GetBaseEntry;
+
+  end;
+
+implementation
+
+uses
+  ClpFiniteFields;
+
+{ TX9FieldID }
+
+class function TX9FieldID.GetInstance(AObj: TObject): IX9FieldID;
+begin
+  if AObj = nil then
+  begin
+    Result := nil;
+    Exit;
+  end;
+
+  if Supports(AObj, IX9FieldID, Result) then
+    Exit;
+
+  Result := TX9FieldID.Create(TAsn1Sequence.GetInstance(AObj));
+end;
+
+class function TX9FieldID.GetInstance(const AObj: IAsn1Convertible): IX9FieldID;
+begin
+  if AObj = nil then
+  begin
+    Result := nil;
+    Exit;
+  end;
+
+  if Supports(AObj, IX9FieldID, Result) then
+    Exit;
+
+  Result := TX9FieldID.Create(TAsn1Sequence.GetInstance(AObj));
+end;
+
+class function TX9FieldID.GetInstance(const AEncoded: TCryptoLibByteArray): IX9FieldID;
+begin
+  Result := TX9FieldID.Create(TAsn1Sequence.GetInstance(AEncoded));
+end;
+
+class function TX9FieldID.GetInstance(const AObj: IAsn1TaggedObject; AExplicitly: Boolean): IX9FieldID;
+begin
+  Result := TX9FieldID.Create(TAsn1Sequence.GetInstance(AObj, AExplicitly));
+end;
+
+class function TX9FieldID.GetOptional(const AElement: IAsn1Encodable): IX9FieldID;
+var
+  LSequence: IAsn1Sequence;
+begin
+  if AElement = nil then
+    raise EArgumentNilCryptoLibException.Create('element');
+
+  if Supports(AElement, IX9FieldID, Result) then
+    Exit;
+
+  LSequence := TAsn1Sequence.GetOptional(AElement);
+  if LSequence <> nil then
+    Result := TX9FieldID.Create(LSequence)
+  else
+    Result := nil;
+end;
+
+class function TX9FieldID.GetTagged(const ATaggedObject: IAsn1TaggedObject;
+  ADeclaredExplicit: Boolean): IX9FieldID;
+begin
+  Result := TX9FieldID.Create(TAsn1Sequence.GetTagged(ATaggedObject, ADeclaredExplicit));
+end;
+
+constructor TX9FieldID.Create(const ASeq: IAsn1Sequence);
+var
+  LCount: Int32;
+begin
+  inherited Create();
+  LCount := ASeq.Count;
+  if LCount <> 2 then
+    raise EArgumentCryptoLibException.CreateResFmt(@SBadSequenceSize, [LCount]);
+
+  FFieldType := TDerObjectIdentifier.GetInstance(ASeq[0]);
+  FParameters := ASeq[1].ToAsn1Object();
+end;
+
+constructor TX9FieldID.Create(const APrimeP: TBigInteger);
+begin
+  inherited Create();
+  FFieldType := TX9ObjectIdentifiers.PrimeField;
+  FParameters := TDerInteger.Create(APrimeP);
+end;
+
+constructor TX9FieldID.Create(AM, AK1: Int32);
+begin
+  Create(AM, AK1, 0, 0);
+end;
+
+constructor TX9FieldID.Create(AM, AK1, AK2, AK3: Int32);
+var
+  LFieldIdParams: IAsn1EncodableVector;
+begin
+  inherited Create();
+  FFieldType := TX9ObjectIdentifiers.CharacteristicTwoField;
+
+  LFieldIdParams := TAsn1EncodableVector.Create(3);
+  LFieldIdParams.Add([TDerInteger.ValueOf(AM)]);
+
+  if AK2 = 0 then
+  begin
+    if AK3 <> 0 then
+      raise EArgumentCryptoLibException.CreateRes(@SInconsistentKValues);
+
+    LFieldIdParams.Add([TX9ObjectIdentifiers.TPBasis, TDerInteger.ValueOf(AK1)]);
+  end
+  else
+  begin
+    if (AK2 <= AK1) or (AK3 <= AK2) then
+      raise EArgumentCryptoLibException.CreateRes(@SInconsistentKValues);
+
+    LFieldIdParams.Add([TX9ObjectIdentifiers.PPBasis, TDerSequence.Create([
+      TDerInteger.ValueOf(AK1), TDerInteger.ValueOf(AK2), TDerInteger.ValueOf(AK3)])]);
+  end;
+
+  FParameters := TDerSequence.Create(LFieldIdParams);
+end;
+
+function TX9FieldID.GetFieldType: IDerObjectIdentifier;
+begin
+  Result := FFieldType;
+end;
+
+function TX9FieldID.GetParameters: IAsn1Object;
+begin
+  Result := FParameters;
+end;
+
+function TX9FieldID.ToAsn1Object: IAsn1Object;
+begin
+  Result := TDerSequence.Create([FFieldType, FParameters]);
+end;
+
+{ TX9FieldElement }
+
+constructor TX9FieldElement.Create(const AF: IECFieldElement);
+begin
+  inherited Create();
+  if AF = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SFieldElementNil);
+  FF := AF;
+end;
+
+function TX9FieldElement.GetValue: IECFieldElement;
+begin
+  Result := FF;
+end;
+
+function TX9FieldElement.ToAsn1Object: IAsn1Object;
+var
+  LByteCount: Int32;
+  LPaddedBigInteger: TCryptoLibByteArray;
+begin
+  LByteCount := TX9IntegerConverter.GetByteLength(FF);
+  LPaddedBigInteger := TX9IntegerConverter.IntegerToBytes(FF.ToBigInteger(), LByteCount);
+  Result := TDerOctetString.Create(LPaddedBigInteger);
+end;
+
+{ TX9Curve }
+
+constructor TX9Curve.Create(const ACurve: IECCurve);
+begin
+  Create(ACurve, nil);
+end;
+
+constructor TX9Curve.Create(const ACurve: IECCurve; const ASeed: TCryptoLibByteArray);
+begin
+  Create(ACurve, TDerBitString.FromContentsOptional(ASeed));
+end;
+
+constructor TX9Curve.Create(const ACurve: IECCurve; const ASeed: IDerBitString);
+var
+  LField: IFiniteField;
+begin
+  inherited Create();
+  if ACurve = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SCurveNil);
+  FCurve := ACurve;
+  FSeed := ASeed;
+
+  LField := ACurve.Field;
+  if TECAlgorithms.IsFpField(LField) then
+  begin
+    FFieldType := TX9ObjectIdentifiers.PrimeField;
+  end
+  else if TECAlgorithms.IsF2mField(LField) then
+  begin
+    FFieldType := TX9ObjectIdentifiers.CharacteristicTwoField;
+  end
+  else
+  begin
+    raise EArgumentCryptoLibException.CreateRes(@SCurveNotImplemented);
+  end;
+end;
+
+constructor TX9Curve.Create(const AFieldID: IX9FieldID; const AOrder, ACofactor: TBigInteger;
+  const ASeq: IAsn1Sequence);
+var
+  LP: TBigInteger;
+  LA, LB: TBigInteger;
+  LParameters: IAsn1Sequence;
+  LM: Int32;
+  LRepresentation: IDerObjectIdentifier;
+  LK1, LK2, LK3: Int32;
+  LPentanomial: IAsn1Sequence;
+  LPolynomialField: IPolynomialExtensionField;
+  LExponents: TCryptoLibInt32Array;
+begin
+  inherited Create();
+  if AFieldID = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SFieldIDNil);
+  if ASeq = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SSeqNil);
+
+  FFieldType := AFieldID.FieldType;
+
+  if TX9ObjectIdentifiers.PrimeField.Equals(FFieldType) then
+  begin
+    LP := TDerInteger.GetInstance(AFieldID.Parameters).Value;
+    LA := TBigInteger.Create(1, TAsn1OctetString.GetInstance(ASeq[0]).GetOctets());
+    LB := TBigInteger.Create(1, TAsn1OctetString.GetInstance(ASeq[1]).GetOctets());
+    FCurve := TFpCurve.Create(LP, LA, LB, AOrder, ACofactor);
+  end
+  else if TX9ObjectIdentifiers.CharacteristicTwoField.Equals(FFieldType) then
+  begin
+    // Characteristic two field
+    LParameters := TAsn1Sequence.GetInstance(AFieldID.Parameters);
+    LM := TDerInteger.GetInstance(LParameters[0]).IntValueExact;
+    LRepresentation := TDerObjectIdentifier.GetInstance(LParameters[1]);
+
+    if TX9ObjectIdentifiers.TPBasis.Equals(LRepresentation) then
+    begin
+      // Trinomial basis representation
+      LK1 := TDerInteger.GetInstance(LParameters[2]).IntValueExact;
+      LK2 := 0;
+      LK3 := 0;
+    end
+    else if TX9ObjectIdentifiers.PPBasis.Equals(LRepresentation) then
+    begin
+      // Pentanomial basis representation
+      LPentanomial := TAsn1Sequence.GetInstance(LParameters[2]);
+      LK1 := TDerInteger.GetInstance(LPentanomial[0]).IntValueExact;
+      LK2 := TDerInteger.GetInstance(LPentanomial[1]).IntValueExact;
+      LK3 := TDerInteger.GetInstance(LPentanomial[2]).IntValueExact;
+    end
+    else
+    begin
+      raise EArgumentCryptoLibException.CreateRes(@SCharacteristicTwoFieldNotImplemented);
+    end;
+
+    LA := TBigInteger.Create(1, TAsn1OctetString.GetInstance(ASeq[0]).GetOctets());
+    LB := TBigInteger.Create(1, TAsn1OctetString.GetInstance(ASeq[1]).GetOctets());
+    FCurve := TF2mCurve.Create(LM, LK1, LK2, LK3, LA, LB, AOrder, ACofactor);
+  end
+  else
+  begin
+    raise EArgumentCryptoLibException.CreateRes(@SCurveNotImplemented);
+  end;
+
+  if ASeq.Count = 3 then
+  begin
+    FSeed := TDerBitString.GetInstance(ASeq[2]);
+  end;
+end;
+
+function TX9Curve.GetCurve: IECCurve;
+begin
+  Result := FCurve;
+end;
+
+function TX9Curve.GetSeed: IDerBitString;
+begin
+  Result := FSeed;
+end;
+
+function TX9Curve.GetSeedBytes: TCryptoLibByteArray;
+begin
+  Result := nil;
+  if FSeed <> nil then
+    Result := FSeed.GetBytes();
+end;
+
+function TX9Curve.ToAsn1Object: IAsn1Object;
+var
+  LA, LB: TX9FieldElement;
+begin
+  LA := TX9FieldElement.Create(FCurve.A);
+  LB := TX9FieldElement.Create(FCurve.B);
+
+  if FSeed = nil then
+    Result := TDerSequence.Create([LA, LB])
+  else
+    Result := TDerSequence.Create([LA, LB, FSeed]);
+end;
+
+{ TX9ECPoint }
+
+constructor TX9ECPoint.Create(const AP: IECPoint; ACompressed: Boolean);
+begin
+  inherited Create();
+  FC := AP.Curve;
+  FP := AP.Normalize();
+  FEncoding := TDerOctetString.Create(AP.GetEncoded(ACompressed));
+  FLock := TCriticalSection.Create;
+end;
+
+constructor TX9ECPoint.Create(const AC: IECCurve; const AEncoding: TCryptoLibByteArray);
+begin
+  Create(AC, TDerOctetString.FromContents(AEncoding));
+end;
+
+constructor TX9ECPoint.Create(const AC: IECCurve; const &AS: IAsn1OctetString);
+begin
+  inherited Create();
+  if AC = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SCurveNil);
+  if &AS = nil then
+    raise EArgumentNilCryptoLibException.CreateRes(@SOctetStringNil);
+  FC := AC;
+  FP := nil;
+  FEncoding := &AS;
+  FLock := TCriticalSection.Create;
+end;
+
+destructor TX9ECPoint.Destroy;
+begin
+  FLock.Free;
+  inherited Destroy;
+end;
+
+function TX9ECPoint.CreatePoint: IECPoint;
+begin
+  Result := FC.DecodePoint(FEncoding.GetOctets());
+end;
+
+function TX9ECPoint.GetPoint: IECPoint;
+begin
+  FLock.Acquire;
+  try
+    if FP = nil then
+    begin
+      FP := CreatePoint();
+    end;
+    Result := FP;
+  finally
+    FLock.Release;
+  end;
+end;
+
+function TX9ECPoint.GetPointEncoding: IAsn1OctetString;
+begin
+  Result := FEncoding;
+end;
+
+function TX9ECPoint.GetIsPointCompressed: Boolean;
+var
+  LOctets: TCryptoLibByteArray;
+begin
+  LOctets := FEncoding.GetOctets();
+  Result := (LOctets <> nil) and (System.Length(LOctets) > 0) and
+    ((LOctets[0] = 2) or (LOctets[0] = 3));
+end;
+
+function TX9ECPoint.ToAsn1Object: IAsn1Object;
+begin
+  Result := FEncoding;
+end;
+
+{ TX9ECParameters }
+
+class function TX9ECParameters.GetInstance(AObj: TObject): IX9ECParameters;
+begin
+  if AObj = nil then
+  begin
+    Result := nil;
+    Exit;
+  end;
+
+  if Supports(AObj, IX9ECParameters, Result) then
+    Exit;
+
+  Result := TX9ECParameters.Create(TAsn1Sequence.GetInstance(AObj));
+end;
+
+class function TX9ECParameters.GetInstance(const AObj: IAsn1Convertible): IX9ECParameters;
+begin
+  if AObj = nil then
+  begin
+    Result := nil;
+    Exit;
+  end;
+
+  if Supports(AObj, IX9ECParameters, Result) then
+    Exit;
+
+  Result := TX9ECParameters.Create(TAsn1Sequence.GetInstance(AObj));
+end;
+
+class function TX9ECParameters.GetInstance(const AEncoded: TCryptoLibByteArray): IX9ECParameters;
+begin
+  Result := TX9ECParameters.Create(TAsn1Sequence.GetInstance(AEncoded));
+end;
+
+class function TX9ECParameters.GetInstance(const AObj: IAsn1TaggedObject;
+  AExplicitly: Boolean): IX9ECParameters;
+begin
+  Result := TX9ECParameters.Create(TAsn1Sequence.GetInstance(AObj, AExplicitly));
+end;
+
+class function TX9ECParameters.GetOptional(const AElement: IAsn1Encodable): IX9ECParameters;
+var
+  LSequence: IAsn1Sequence;
+begin
+  if AElement = nil then
+    raise EArgumentNilCryptoLibException.Create('element');
+
+  if Supports(AElement, IX9ECParameters, Result) then
+    Exit;
+
+  LSequence := TAsn1Sequence.GetOptional(AElement);
+  if LSequence <> nil then
+    Result := TX9ECParameters.Create(LSequence)
+  else
+    Result := nil;
+end;
+
+class function TX9ECParameters.GetTagged(const ATaggedObject: IAsn1TaggedObject;
+  ADeclaredExplicit: Boolean): IX9ECParameters;
+begin
+  Result := TX9ECParameters.Create(TAsn1Sequence.GetTagged(ATaggedObject, ADeclaredExplicit));
+end;
+
+constructor TX9ECParameters.Create(const ASeq: IAsn1Sequence);
+var
+  LCount, LPos: Int32;
+  LVersion: IDerInteger;
+  LX9CurveSequence: IAsn1Sequence;
+  LP: IAsn1Encodable;
+  LX9ECPoint: IX9ECPoint;
+begin
+  inherited Create();
+  LCount := ASeq.Count;
+  LPos := 0;
+  if (LCount < 5) or (LCount > 6) then
+    raise EArgumentCryptoLibException.CreateResFmt(@SBadSequenceSize, [LCount]);
+
+  LVersion := TDerInteger.GetInstance(ASeq[LPos] as TAsn1Encodable);
+  System.Inc(LPos);
+  FFieldID := TX9FieldID.GetInstance(ASeq[LPos] as TAsn1Encodable);
+  System.Inc(LPos);
+  LX9CurveSequence := TAsn1Sequence.GetInstance(ASeq[LPos]);
+  System.Inc(LPos);
+  LP := ASeq[LPos] as TAsn1Encodable;
+  System.Inc(LPos);
+  FN := (TDerInteger.GetInstance(ASeq[LPos] as TAsn1Encodable) as IDerInteger).Value;
+  System.Inc(LPos);
+  FH := TAsn1Utilities.ReadOptional<TBigInteger>(ASeq, LPos, function(AElement: IAsn1Encodable): TBigInteger
+    var
+      LDerInt: IDerInteger;
+    begin
+      LDerInt := TDerInteger.GetOptional(AElement);
+      if LDerInt <> nil then
+        Result := LDerInt.Value
+      else
+        Result := Default(TBigInteger);
+    end);
+
+  if LPos <> LCount then
+    raise EArgumentCryptoLibException.CreateRes(@SUnexpectedElementsInSequence);
+
+  if not LVersion.HasValue(1) then
+    raise EArgumentCryptoLibException.CreateRes(@SBadVersion);
+
+  FCurve := TX9Curve.Create(FFieldID, FN, FH, LX9CurveSequence);
+
+  if Supports(LP, IX9ECPoint, LX9ECPoint) then
+  begin
+    FG := LX9ECPoint;
+  end
+  else
+  begin
+    FG := TX9ECPoint.Create(FCurve.Curve, TAsn1OctetString.GetInstance(LP));
+  end;
+end;
+
+constructor TX9ECParameters.Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+  const AN: TBigInteger);
+begin
+  Create(ACurve, AG, AN, TBigInteger.GetDefault, nil);
+end;
+
+constructor TX9ECParameters.Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+  const AN, AH: TBigInteger);
+begin
+  Create(ACurve, AG, AN, AH, nil);
+end;
+
+constructor TX9ECParameters.Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+  const AN, AH: TBigInteger; const ASeed: TCryptoLibByteArray);
+begin
+  Create(ACurve, AG, AN, AH, TDerBitString.FromContentsOptional(ASeed));
+end;
+
+constructor TX9ECParameters.Create(const ACurve: IECCurve; const AG: IX9ECPoint;
+  const AN, AH: TBigInteger; const ASeed: IDerBitString);
+var
+  LField: IFiniteField;
+  LF2mField: IPolynomialExtensionField;
+  LExponents: TCryptoLibInt32Array;
+begin
+  inherited Create();
+  FCurve := TX9Curve.Create(ACurve, ASeed);
+  FG := AG;
+  FN := AN;
+  FH := AH;
+
+  LField := ACurve.Field;
+  if TECAlgorithms.IsFpField(LField) then
+  begin
+    FFieldID := TX9FieldID.Create(LField.Characteristic);
+  end
+  else if TECAlgorithms.IsF2mField(LField) then
+  begin
+    if not Supports(LField, IPolynomialExtensionField, LF2mField) then
+      raise EArgumentCryptoLibException.CreateRes(@SUnsupportedCurveType);
+
+    LExponents := LF2mField.MinimalPolynomial.GetExponentsPresent();
+    if System.Length(LExponents) = 3 then
+    begin
+      FFieldID := TX9FieldID.Create(LExponents[2], LExponents[1]);
+    end
+    else if System.Length(LExponents) = 5 then
+    begin
+      FFieldID := TX9FieldID.Create(LExponents[4], LExponents[1], LExponents[2], LExponents[3]);
+    end
+    else
+    begin
+      raise EArgumentCryptoLibException.CreateRes(@SOnlyTrinomialAndPentanomial);
+    end;
+  end
+  else
+  begin
+    raise EArgumentCryptoLibException.CreateRes(@SUnsupportedCurveType);
+  end;
+end;
+
+function TX9ECParameters.GetCurve: IECCurve;
+begin
+  Result := FCurve.Curve;
+end;
+
+function TX9ECParameters.GetG: IECPoint;
+begin
+  Result := FG.Point;
+end;
+
+function TX9ECParameters.GetN: TBigInteger;
+begin
+  Result := FN;
+end;
+
+function TX9ECParameters.GetH: TBigInteger;
+begin
+  Result := FH;
+end;
+
+function TX9ECParameters.GetCurveEntry: IX9Curve;
+begin
+  Result := FCurve;
+end;
+
+function TX9ECParameters.GetFieldIDEntry: IX9FieldID;
+begin
+  Result := FFieldID;
+end;
+
+function TX9ECParameters.GetBaseEntry: IX9ECPoint;
+begin
+  Result := FG;
+end;
+
+function TX9ECParameters.GetSeed: TCryptoLibByteArray;
+begin
+  Result := FCurve.GetSeedBytes();
+end;
+
+function TX9ECParameters.ToAsn1Object: IAsn1Object;
+var
+  LV: IAsn1EncodableVector;
+begin
+  LV := TAsn1EncodableVector.Create(6);
+  LV.Add([TDerInteger.One, FFieldID, FCurve, FG, TDerInteger.Create(FN) as IDerInteger]);
+
+  if FH.IsInitialized then
+  begin
+    LV.Add([TDerInteger.Create(FH) as IDerInteger]);
+  end;
+
+  Result := TDerSequence.Create(LV);
+end;
+
+end.

CryptoLib/src/Asn1/X9/ClpX9ECC.pas

@@ -1,636 +0,0 @@
-{ *********************************************************************************** }
-{ *                              CryptoLib Library                                  * }
-{ *                Copyright (c) 2018 - 20XX Ugochukwu Mmaduekwe                    * }
-{ *                 Github Repository <https://github.com/Xor-el>                   * }
-
-{ *  Distributed under the MIT software license, see the accompanying file LICENSE  * }
-{ *          or visit http://www.opensource.org/licenses/mit-license.php.           * }
-
-{ *                              Acknowledgements:                                  * }
-{ *                                                                                 * }
-{ *      Thanks to Sphere 10 Software (http://www.sphere10.com/) for sponsoring     * }
-{ *                           development of this library                           * }
-
-{ * ******************************************************************************* * }
-
-(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
-
-unit ClpX9ECC;
-
-{$I ..\..\Include\CryptoLib.inc}
-
-interface
-
-uses
-  ClpECC,
-  ClpIECC,
-  ClpIX9ECC,
-  ClpAsn1Core,
-  ClpIAsn1Core,
-  ClpCryptoLibTypes,
-  ClpECAlgorithms,
-  ClpBigInteger,
-  ClpX9ObjectIdentifiers,
-  ClpAsn1Objects,
-  ClpIAsn1Objects;
-
-resourcestring
-  SInconsistentKValues = 'Inconsistent K Values';
-  SCurveNil = 'Curve';
-  SNotImplementedECCurve = 'This Type of ECCurve is not Implemented';
-  SFieldIDNil = 'FieldID';
-  SSeqNil = 'Seq';
-
-type
-  TX9IntegerConverter = class sealed(TObject)
-
-  public
-
-    class function GetByteLength(const fe: IECFieldElement): Int32; overload;
-      static; inline;
-    class function GetByteLength(const c: IECCurve): Int32; overload;
-      static; inline;
-
-    class function IntegerToBytes(const s: TBigInteger; qLength: Int32)
-      : TCryptoLibByteArray; static;
-
-  end;
-
-type
-
-  /// <summary>
-  /// ASN.1 def for Elliptic-Curve Field ID structure. See X9.62, for further
-  /// details.
-  /// </summary>
-  TX9FieldID = class(TAsn1Encodable, IX9FieldID)
-
-  strict private
-  var
-    Fid: IDerObjectIdentifier;
-    Fparameters: IAsn1Object;
-
-    function GetIdentifier: IDerObjectIdentifier; inline;
-    function GetParameters: IAsn1Object; inline;
-
-    constructor Create(const seq: IAsn1Sequence); overload;
-
-  public
-    // /**
-    // * Constructor for elliptic curves over prime fields
-    // * <code>F<sub>2</sub></code>.
-    // * @param primeP The prime <code>p</code> defining the prime field.
-    // */
-    constructor Create(const primeP: TBigInteger); overload;
-    // /**
-    // * Constructor for elliptic curves over binary fields
-    // * <code>F<sub>2<sup>m</sup></sub></code>.
-    // * @param m  The exponent <code>m</code> of
-    // * <code>F<sub>2<sup>m</sup></sub></code>.
-    // * @param k1 The integer <code>k1</code> where <code>x<sup>m</sup> +
-    // * x<sup>k1</sup> + 1</code>
-    // * represents the reduction polynomial <code>f(z)</code>.
-    // */
-    constructor Create(m, k1: Int32); overload;
-    // /**
-    // * Constructor for elliptic curves over binary fields
-    // * <code>F<sub>2<sup>m</sup></sub></code>.
-    // * @param m  The exponent <code>m</code> of
-    // * <code>F<sub>2<sup>m</sup></sub></code>.
-    // * @param k1 The integer <code>k1</code> where <code>x<sup>m</sup> +
-    // * x<sup>k3</sup> + x<sup>k2</sup> + x<sup>k1</sup> + 1</code>
-    // * represents the reduction polynomial <code>f(z)</code>.
-    // * @param k2 The integer <code>k2</code> where <code>x<sup>m</sup> +
-    // * x<sup>k3</sup> + x<sup>k2</sup> + x<sup>k1</sup> + 1</code>
-    // * represents the reduction polynomial <code>f(z)</code>.
-    // * @param k3 The integer <code>k3</code> where <code>x<sup>m</sup> +
-    // * x<sup>k3</sup> + x<sup>k2</sup> + x<sup>k1</sup> + 1</code>
-    // * represents the reduction polynomial <code>f(z)</code>..
-    // */
-    constructor Create(m, k1, k2, k3: Int32); overload;
-
-    property Identifier: IDerObjectIdentifier read GetIdentifier;
-
-    property Parameters: IAsn1Object read GetParameters;
-
-    /// <summary>
-    /// <para>
-    /// Produce a Der encoding of the following structure. <br />
-    /// &lt;pre&gt;
-    /// </para>
-    /// <para>
-    /// FieldID ::= Sequence { fieldType FIELD-ID.&amp;amp;id({IOSet}),
-    /// parameters FIELD-ID.&amp;amp;Type({IOSet}{&amp;#64;fieldType})} <br />
-    /// </para>
-    /// <para>
-    /// &lt;/pre&gt; <br />
-    /// </para>
-    /// </summary>
-    function ToAsn1Object(): IAsn1Object; override;
-
-    class function GetInstance(obj: TObject): IX9FieldID; static;
-
-  end;
-
-type
-
-  /// <summary>
-  /// Class for processing an ECFieldElement as a DER object.
-  /// </summary>
-  TX9FieldElement = class(TAsn1Encodable, IX9FieldElement)
-
-  strict private
-  var
-    Ff: IECFieldElement;
-
-    function GetValue: IECFieldElement; inline;
-
-  public
-    constructor Create(const f: IECFieldElement); overload;
-    constructor Create(const p: TBigInteger; const s: IAsn1OctetString);
-      overload; deprecated 'Will be removed';
-    constructor Create(m, k1, k2, k3: Int32; const s: IAsn1OctetString);
-      overload; deprecated 'Will be removed';
-
-    // /**
-    // * Produce an object suitable for an Asn1OutputStream.
-    // * <pre>
-    // *  FieldElement ::= OCTET STRING
-    // * </pre>
-    // * <p>
-    // * <ol>
-    // * <li> if <i>q</i> is an odd prime then the field element is
-    // * processed as an Integer and converted to an octet string
-    // * according to x 9.62 4.3.1.</li>
-    // * <li> if <i>q</i> is 2<sup>m</sup> then the bit string
-    // * contained in the field element is converted into an octet
-    // * string with the same ordering padded at the front if necessary.
-    // * </li>
-    // * </ol>
-    // * </p>
-    // */
-    function ToAsn1Object(): IAsn1Object; override;
-
-    property Value: IECFieldElement read GetValue;
-
-  end;
-
-type
-  // /**
-  // * class for describing an ECPoint as a Der object.
-  // */
-  TX9ECPoint = class sealed(TAsn1Encodable, IX9ECPoint)
-
-  strict private
-  var
-    Fencoding: IAsn1OctetString;
-    Fc: IECCurve;
-    Fp: IECPoint;
-
-    function GetIsPointCompressed: Boolean; inline;
-    function GetPoint: IECPoint; inline;
-
-  public
-
-    constructor Create(const p: IECPoint); overload;
-    constructor Create(const p: IECPoint; compressed: Boolean); overload;
-    constructor Create(const c: IECCurve;
-      const encoding: TCryptoLibByteArray); overload;
-    constructor Create(const c: IECCurve; const s: IAsn1OctetString); overload;
-
-    property Point: IECPoint read GetPoint;
-    property IsPointCompressed: Boolean read GetIsPointCompressed;
-
-    function GetPointEncoding(): TCryptoLibByteArray; inline;
-
-    // /**
-    // * Produce an object suitable for an Asn1OutputStream.
-    // * <pre>
-    // *  ECPoint ::= OCTET STRING
-    // * </pre>
-    // * <p>
-    // * Octet string produced using ECPoint.GetEncoded().</p>
-    // */
-    function ToAsn1Object(): IAsn1Object; override;
-
-  end;
-
-type
-
-  /// <summary>
-  /// ASN.1 def for Elliptic-Curve Curve structure. See X9.62, for further
-  /// details.
-  /// </summary>
-  TX9Curve = class(TAsn1Encodable, IX9Curve)
-
-  strict private
-  var
-    FSeed: TCryptoLibByteArray;
-    FfieldIdentifier: IDerObjectIdentifier;
-    Fcurve: IECCurve;
-
-    function GetCurve: IECCurve; inline;
-
-  public
-    constructor Create(const curve: IECCurve); overload;
-    constructor Create(const curve: IECCurve;
-      const seed: TCryptoLibByteArray); overload;
-    constructor Create(const fieldID: IX9FieldID; const seq: IAsn1Sequence);
-      overload; deprecated 'Use constructor including order/cofactor';
-
-    constructor Create(const fieldID: IX9FieldID;
-      const order, cofactor: TBigInteger; const seq: IAsn1Sequence); overload;
-
-    function GetSeed(): TCryptoLibByteArray; inline;
-
-    property curve: IECCurve read GetCurve;
-
-    /// <summary>
-    /// <para>
-    /// Produce an object suitable for an Asn1OutputStream. <br />
-    /// &lt;pre&gt;
-    /// </para>
-    /// <para>
-    /// Curve ::= Sequence { a FieldElement, b FieldElement, seed BIT
-    /// STRING OPTIONAL }
-    /// </para>
-    /// <para>
-    /// <br />&lt;/pre&gt;
-    /// </para>
-    /// </summary>
-    function ToAsn1Object(): IAsn1Object; override;
-
-  end;
-
-implementation
-
-{ TX9IntegerConverter }
-
-class function TX9IntegerConverter.GetByteLength
-  (const fe: IECFieldElement): Int32;
-begin
-  result := (fe.FieldSize + 7) div 8;
-end;
-
-class function TX9IntegerConverter.GetByteLength(const c: IECCurve): Int32;
-begin
-  result := (c.FieldSize + 7) div 8;
-end;
-
-class function TX9IntegerConverter.IntegerToBytes(const s: TBigInteger;
-  qLength: Int32): TCryptoLibByteArray;
-var
-  bytes, tmp: TCryptoLibByteArray;
-begin
-  bytes := s.ToByteArrayUnsigned();
-
-  if (qLength < System.Length(bytes)) then
-  begin
-    System.SetLength(tmp, qLength);
-    System.Move(bytes[System.Length(bytes) - System.Length(tmp)], tmp[0],
-      System.Length(tmp) * System.SizeOf(Byte));
-    result := tmp;
-    Exit;
-  end;
-  if (qLength > System.Length(bytes)) then
-  begin
-    System.SetLength(tmp, qLength);
-    System.Move(bytes[0], tmp[System.Length(tmp) - System.Length(bytes)],
-      System.Length(bytes) * System.SizeOf(Byte));
-    result := tmp;
-    Exit;
-  end;
-
-  result := bytes;
-end;
-
-{ TX9FieldID }
-
-constructor TX9FieldID.Create(m, k1: Int32);
-begin
-  Create(m, k1, 0, 0);
-end;
-
-constructor TX9FieldID.Create(const primeP: TBigInteger);
-begin
-  Inherited Create();
-  Fid := TX9ObjectIdentifiers.PrimeField;
-  Fparameters := TDerInteger.Create(primeP);
-end;
-
-constructor TX9FieldID.Create(const seq: IAsn1Sequence);
-begin
-  Inherited Create();
-  Fid := TDerObjectIdentifier.GetInstance(seq[0] as TAsn1Encodable);
-  Fparameters := seq[1].ToAsn1Object();
-end;
-
-constructor TX9FieldID.Create(m, k1, k2, k3: Int32);
-var
-  fieldIdParams: IAsn1EncodableVector;
-begin
-  inherited Create();
-  Fid := TX9ObjectIdentifiers.CharacteristicTwoField;
-
-  fieldIdParams := TAsn1EncodableVector.Create
-    ([TDerInteger.Create(m) as IDerInteger]);
-
-  if (k2 = 0) then
-  begin
-    if (k3 <> 0) then
-    begin
-      raise EArgumentCryptoLibException.CreateRes(@SInconsistentKValues);
-    end;
-
-    fieldIdParams.Add([TX9ObjectIdentifiers.TPBasis, TDerInteger.Create(k1)
-      as IDerInteger]);
-  end
-  else
-  begin
-    if ((k2 <= k1) or (k3 <= k2)) then
-    begin
-      raise EArgumentCryptoLibException.CreateRes(@SInconsistentKValues);
-
-    end;
-
-    fieldIdParams.Add([TX9ObjectIdentifiers.PPBasis,
-      TDerSequence.Create([TDerInteger.Create(k1) as IDerInteger,
-      TDerInteger.Create(k2) as IDerInteger, TDerInteger.Create(k3)
-      as IDerInteger])]);
-  end;
-
-  Fparameters := TDerSequence.Create(fieldIdParams);
-end;
-
-function TX9FieldID.GetIdentifier: IDerObjectIdentifier;
-begin
-  result := Fid;
-end;
-
-class function TX9FieldID.GetInstance(obj: TObject): IX9FieldID;
-var
-  x9FieldId: IX9FieldID;
-begin
-  x9FieldId := obj as TX9FieldID;
-  if (x9FieldId <> Nil) then
-  begin
-    result := x9FieldId;
-    Exit;
-  end;
-  if (obj = Nil) then
-  begin
-    result := Nil;
-    Exit;
-  end;
-  result := TX9FieldID.Create(TAsn1Sequence.GetInstance(obj));
-end;
-
-function TX9FieldID.GetParameters: IAsn1Object;
-begin
-  result := Fparameters;
-end;
-
-function TX9FieldID.ToAsn1Object: IAsn1Object;
-begin
-  result := TDerSequence.Create([Fid, Fparameters]);
-end;
-
-{ TX9FieldElement }
-
-constructor TX9FieldElement.Create(const p: TBigInteger;
-  const s: IAsn1OctetString);
-begin
-  Create(TFpFieldElement.Create(p, TBigInteger.Create(1, s.GetOctets()))
-    as IFpFieldElement)
-end;
-
-constructor TX9FieldElement.Create(const f: IECFieldElement);
-begin
-  Inherited Create();
-  Ff := f;
-end;
-
-constructor TX9FieldElement.Create(m, k1, k2, k3: Int32;
-  const s: IAsn1OctetString);
-begin
-  Create(TF2mFieldElement.Create(m, k1, k2, k3, TBigInteger.Create(1,
-    s.GetOctets())) as IF2mFieldElement)
-end;
-
-function TX9FieldElement.GetValue: IECFieldElement;
-begin
-  result := Ff;
-end;
-
-function TX9FieldElement.ToAsn1Object: IAsn1Object;
-var
-  byteCount: Int32;
-  paddedBigInteger: TCryptoLibByteArray;
-begin
-  byteCount := TX9IntegerConverter.GetByteLength(Ff);
-  paddedBigInteger := TX9IntegerConverter.IntegerToBytes(Ff.ToBigInteger(),
-    byteCount);
-
-  result := TDerOctetString.Create(paddedBigInteger);
-end;
-
-{ TX9ECPoint }
-
-constructor TX9ECPoint.Create(const c: IECCurve;
-  const encoding: TCryptoLibByteArray);
-begin
-  inherited Create();
-  Fc := c;
-  Fencoding := TDerOctetString.Create(System.Copy(encoding));
-end;
-
-constructor TX9ECPoint.Create(const p: IECPoint; compressed: Boolean);
-begin
-  inherited Create();
-  Fp := p.Normalize();
-  Fencoding := TDerOctetString.Create(p.GetEncoded(compressed));
-end;
-
-constructor TX9ECPoint.Create(const p: IECPoint);
-begin
-  Create(p, false);
-end;
-
-constructor TX9ECPoint.Create(const c: IECCurve; const s: IAsn1OctetString);
-begin
-  Create(c, s.GetOctets());
-end;
-
-function TX9ECPoint.GetPointEncoding(): TCryptoLibByteArray;
-begin
-  result := Fencoding.GetOctets();
-end;
-
-function TX9ECPoint.GetIsPointCompressed: Boolean;
-var
-  octets: TCryptoLibByteArray;
-begin
-  octets := Fencoding.GetOctets();
-  result := (octets <> Nil) and (System.Length(octets) > 0) and
-    ((octets[0] = 2) or (octets[0] = 3));
-end;
-
-function TX9ECPoint.GetPoint: IECPoint;
-begin
-  if (Fp = Nil) then
-  begin
-    Fp := Fc.DecodePoint(Fencoding.GetOctets()).Normalize();
-  end;
-
-  result := Fp;
-end;
-
-function TX9ECPoint.ToAsn1Object: IAsn1Object;
-begin
-  result := Fencoding;
-end;
-
-{ TX9Curve }
-
-constructor TX9Curve.Create(const curve: IECCurve;
-  const seed: TCryptoLibByteArray);
-begin
-  Inherited Create();
-  if (curve = Nil) then
-  begin
-    raise EArgumentNilCryptoLibException.CreateRes(@SCurveNil);
-  end;
-
-  Fcurve := curve;
-  FSeed := System.Copy(seed);
-
-  if (TECAlgorithms.IsFpCurve(curve)) then
-  begin
-    FfieldIdentifier := TX9ObjectIdentifiers.PrimeField;
-  end
-  else if (TECAlgorithms.IsF2mCurve(curve)) then
-  begin
-    FfieldIdentifier := TX9ObjectIdentifiers.CharacteristicTwoField;
-  end
-  else
-  begin
-    raise EArgumentCryptoLibException.CreateRes(@SNotImplementedECCurve);
-  end;
-end;
-
-constructor TX9Curve.Create(const curve: IECCurve);
-begin
-  Create(curve, Nil);
-end;
-
-constructor TX9Curve.Create(const fieldID: IX9FieldID;
-  const seq: IAsn1Sequence);
-begin
-  Create(fieldID, Default (TBigInteger), Default (TBigInteger), seq);
-end;
-
-constructor TX9Curve.Create(const fieldID: IX9FieldID;
-  const order, cofactor: TBigInteger; const seq: IAsn1Sequence);
-var
-  p, A, B: TBigInteger;
-  Parameters: IDerSequence;
-  representation: IDerObjectIdentifier;
-  pentanomial: IDerSequence;
-  m, k1, k2, k3: Int32;
-begin
-  Inherited Create();
-  if (fieldID = Nil) then
-  begin
-    raise EArgumentNilCryptoLibException.CreateRes(@SFieldIDNil);
-  end;
-  if (seq = Nil) then
-  begin
-    raise EArgumentNilCryptoLibException.CreateRes(@SSeqNil);
-  end;
-
-  FfieldIdentifier := fieldID.Identifier;
-
-  if (FfieldIdentifier.Equals(TX9ObjectIdentifiers.PrimeField)) then
-  begin
-    p := (fieldID.Parameters as IDerInteger).Value;
-    A := TBigInteger.Create(1,
-      TAsn1OctetString.GetInstance(seq[0] as TAsn1Encodable).GetOctets());
-    B := TBigInteger.Create(1,
-      TAsn1OctetString.GetInstance(seq[1] as TAsn1Encodable).GetOctets());
-    Fcurve := TFpCurve.Create(p, A, B, order, cofactor);
-  end
-  else if (FfieldIdentifier.Equals(TX9ObjectIdentifiers.CharacteristicTwoField))
-  then
-  begin
-    // Characteristic two field
-    Parameters := fieldID.Parameters as IDerSequence;
-    m := (Parameters[0] as IDerInteger).Value.Int32Value;
-    representation := Parameters[1] as IDerObjectIdentifier;
-
-    k2 := 0;
-    k3 := 0;
-    if (representation.Equals(TX9ObjectIdentifiers.TPBasis)) then
-    begin
-      // Trinomial basis representation
-      k1 := (Parameters[2] as IDerInteger).Value.Int32Value;
-    end
-    else
-    begin
-      // Pentanomial basis representation
-      pentanomial := Parameters[2] as IDerSequence;
-      k1 := (pentanomial[0] as IDerInteger).Value.Int32Value;
-      k2 := (pentanomial[1] as IDerInteger).Value.Int32Value;
-      k3 := (pentanomial[2] as IDerInteger).Value.Int32Value;
-    end;
-    A := TBigInteger.Create(1,
-      TAsn1OctetString.GetInstance(seq[0] as TAsn1Encodable).GetOctets());
-    B := TBigInteger.Create(1,
-      TAsn1OctetString.GetInstance(seq[1] as TAsn1Encodable).GetOctets());
-
-    Fcurve := TF2mCurve.Create(m, k1, k2, k3, A, B, order, cofactor);
-  end
-  else
-  begin
-    raise EArgumentCryptoLibException.CreateRes(@SNotImplementedECCurve);
-  end;
-
-  if (seq.Count = 3) then
-  begin
-    FSeed := (seq[2] as IDerBitString).GetBytes();
-  end;
-
-end;
-
-function TX9Curve.GetCurve: IECCurve;
-begin
-  result := Fcurve;
-end;
-
-function TX9Curve.GetSeed: TCryptoLibByteArray;
-begin
-  result := System.Copy(FSeed);
-end;
-
-function TX9Curve.ToAsn1Object: IAsn1Object;
-var
-  v: IAsn1EncodableVector;
-begin
-  v := TAsn1EncodableVector.Create();
-
-  if (FfieldIdentifier.Equals(TX9ObjectIdentifiers.PrimeField) or
-    FfieldIdentifier.Equals(TX9ObjectIdentifiers.CharacteristicTwoField)) then
-  begin
-    v.Add([(TX9FieldElement.Create(Fcurve.A) as IX9FieldElement)
-      .ToAsn1Object()]);
-    v.Add([(TX9FieldElement.Create(Fcurve.B) as IX9FieldElement)
-      .ToAsn1Object()]);
-  end;
-
-  if (FSeed <> Nil) then
-  begin
-    v.Add([TDerBitString.Create(FSeed) as IDerBitString]);
-  end;
-
-  result := TDerSequence.Create(v);
-end;
-
-end.

CryptoLib/src/Asn1/X9/ClpX9ECParameters.pas

@@ -1,319 +0,0 @@
-{ *********************************************************************************** }
-{ *                              CryptoLib Library                                  * }
-{ *                Copyright (c) 2018 - 20XX Ugochukwu Mmaduekwe                    * }
-{ *                 Github Repository <https://github.com/Xor-el>                   * }
-
-{ *  Distributed under the MIT software license, see the accompanying file LICENSE  * }
-{ *          or visit http://www.opensource.org/licenses/mit-license.php.           * }
-
-{ *                              Acknowledgements:                                  * }
-{ *                                                                                 * }
-{ *      Thanks to Sphere 10 Software (http://www.sphere10.com/) for sponsoring     * }
-{ *                           development of this library                           * }
-
-{ * ******************************************************************************* * }
-
-(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
-
-unit ClpX9ECParameters;
-
-{$I ..\..\Include\CryptoLib.inc}
-
-interface
-
-uses
-  SysUtils,
-  ClpCryptoLibTypes,
-  ClpBigInteger,
-  ClpIPolynomialExtensionField,
-  ClpIAsn1Objects,
-  ClpAsn1Core,
-  ClpIAsn1Core,
-  ClpIECC,
-  ClpECAlgorithms,
-  ClpX9ECC,
-  ClpIX9ECC,
-  ClpAsn1Objects,
-  ClpIX9ECParameters;
-
-resourcestring
-  SUnSupportedCurveOne = 'Only trinomial and pentomial curves are supported';
-  SUnSupportedCurveTwo = '"curve" is of an unsupported type';
-  SBadVersion = 'Bad Version in X9ECParameters';
-
-type
-  /// **
-  // * ASN.1 def for Elliptic-Curve ECParameters structure. See
-  // * X9.62, for further details.
-  // */
-  TX9ECParameters = class sealed(TAsn1Encodable, IX9ECParameters)
-
-  strict private
-  var
-    FfieldID: IX9FieldID;
-    Fcurve: IECCurve;
-    Fg: IX9ECPoint;
-    Fn, Fh: TBigInteger;
-    Fseed: TCryptoLibByteArray;
-
-    function GetCurve: IECCurve; inline;
-    function GetG: IECPoint; inline;
-    function GetH: TBigInteger; inline;
-    function GetN: TBigInteger; inline;
-    function GetBaseEntry: IX9ECPoint; inline;
-    function GetCurveEntry: IX9Curve; inline;
-    function GetFieldIDEntry: IX9FieldID; inline;
-
-  public
-
-    constructor Create(const seq: IAsn1Sequence); overload;
-    constructor Create(const curve: IECCurve; const g: IECPoint;
-      const n: TBigInteger); overload;
-    constructor Create(const curve: IECCurve; const g: IX9ECPoint;
-      const n, h: TBigInteger); overload;
-    constructor Create(const curve: IECCurve; const g: IECPoint;
-      const n, h: TBigInteger); overload;
-    constructor Create(const curve: IECCurve; const g: IECPoint;
-      const n, h: TBigInteger; const seed: TCryptoLibByteArray); overload;
-    constructor Create(const curve: IECCurve; const g: IX9ECPoint;
-      const n, h: TBigInteger; const seed: TCryptoLibByteArray); overload;
-
-    property curve: IECCurve read GetCurve;
-    property g: IECPoint read GetG;
-    property n: TBigInteger read GetN;
-    property h: TBigInteger read GetH;
-    property CurveEntry: IX9Curve read GetCurveEntry;
-    property FieldIDEntry: IX9FieldID read GetFieldIDEntry;
-    property BaseEntry: IX9ECPoint read GetBaseEntry;
-
-    function GetSeed(): TCryptoLibByteArray;
-
-    function ToAsn1Object(): IAsn1Object; override;
-
-    class function GetInstance(obj: TObject): IX9ECParameters; static;
-
-    class function GetOptional(const AElement: IAsn1Encodable): IX9ECParameters; static;
-
-  end;
-
-implementation
-
-{ TX9ECParameters }
-
-function TX9ECParameters.GetBaseEntry: IX9ECPoint;
-begin
-  Result := Fg;
-end;
-
-function TX9ECParameters.GetFieldIDEntry: IX9FieldID;
-begin
-  Result := FfieldID;
-end;
-
-function TX9ECParameters.GetG: IECPoint;
-begin
-  Result := Fg.Point;
-end;
-
-function TX9ECParameters.GetH: TBigInteger;
-begin
-  Result := Fh;
-end;
-
-function TX9ECParameters.GetCurve: IECCurve;
-begin
-  Result := Fcurve;
-end;
-
-constructor TX9ECParameters.Create(const curve: IECCurve; const g: IX9ECPoint;
-  const n, h: TBigInteger);
-begin
-  Create(curve, g, n, h, Nil);
-end;
-
-constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
-  const n: TBigInteger);
-begin
-  Create(curve, g, n, Default (TBigInteger), Nil);
-end;
-
-constructor TX9ECParameters.Create(const seq: IAsn1Sequence);
-var
-  x9c: IX9Curve;
-  p: TObject;
-  ecPoint: IX9ECPoint;
-begin
-  Inherited Create();
-  if ((not(Supports(seq[0], IDerInteger))) or
-    (not(seq[0] as IDerInteger).Value.Equals(TBigInteger.One))) then
-  begin
-    raise EArgumentCryptoLibException.CreateRes(@SBadVersion);
-  end;
-
-  Fn := (seq[4] as IDerInteger).Value;
-
-  if (seq.Count = 6) then
-  begin
-    Fh := (seq[5] as IDerInteger).Value;
-  end;
-
-  x9c := TX9Curve.Create(TX9FieldID.GetInstance(seq[1] as TAsn1Sequence), Fn,
-    Fh, TAsn1Sequence.GetInstance(seq[2] as TAsn1Sequence));
-
-  Fcurve := x9c.curve;
-  p := seq[3] as TAsn1Sequence;
-
-  ecPoint := p as TX9ECPoint;
-  if (ecPoint <> Nil) then
-  begin
-    Fg := ecPoint;
-  end
-  else
-  begin
-    Fg := TX9ECPoint.Create(curve, p as TAsn1OctetString);
-  end;
-
-  Fseed := x9c.GetSeed();
-end;
-
-constructor TX9ECParameters.Create(const curve: IECCurve; const g: IX9ECPoint;
-  const n, h: TBigInteger; const seed: TCryptoLibByteArray);
-var
-  exponents: TCryptoLibInt32Array;
-  Field: IPolynomialExtensionField;
-begin
-  Inherited Create();
-  Fcurve := curve;
-  Fg := g;
-  Fn := n;
-  Fh := h;
-  Fseed := seed;
-
-  if (TECAlgorithms.IsFpCurve(curve)) then
-  begin
-    FfieldID := TX9FieldID.Create(curve.Field.Characteristic);
-  end
-  else if (TECAlgorithms.IsF2mCurve(curve)) then
-  begin
-    Field := curve.Field as IPolynomialExtensionField;
-    exponents := Field.MinimalPolynomial.GetExponentsPresent();
-    if (System.Length(exponents) = 3) then
-    begin
-      FfieldID := TX9FieldID.Create(exponents[2], exponents[1]);
-    end
-    else if (System.Length(exponents) = 5) then
-    begin
-      FfieldID := TX9FieldID.Create(exponents[4], exponents[1], exponents[2],
-        exponents[3]);
-    end
-    else
-    begin
-
-      raise EArgumentCryptoLibException.CreateRes(@SUnSupportedCurveOne);
-    end
-  end
-  else
-  begin
-    raise EArgumentCryptoLibException.CreateRes(@SUnSupportedCurveTwo);
-
-  end;
-end;
-
-constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
-  const n, h: TBigInteger; const seed: TCryptoLibByteArray);
-begin
-  Create(curve, TX9ECPoint.Create(g) as IX9ECPoint, n, h, seed)
-end;
-
-constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
-  const n, h: TBigInteger);
-begin
-  Create(curve, g, n, h, Nil);
-end;
-
-function TX9ECParameters.GetCurveEntry: IX9Curve;
-begin
-  Result := TX9Curve.Create(Fcurve, Fseed);
-end;
-
-class function TX9ECParameters.GetInstance(obj: TObject): IX9ECParameters;
-var
-  instance: IX9ECParameters;
-begin
-  instance := obj as TX9ECParameters;
-  if (instance <> Nil) then
-  begin
-    Result := instance;
-    Exit;
-  end;
-
-  if (obj <> Nil) then
-  begin
-    Result := TX9ECParameters.Create(TAsn1Sequence.GetInstance(obj));
-    Exit;
-  end;
-
-  Result := Nil;
-end;
-
-class function TX9ECParameters.GetOptional(const AElement: IAsn1Encodable): IX9ECParameters;
-var
-  LSequence: IAsn1Sequence;
-begin
-  if AElement = nil then
-    raise EArgumentNilCryptoLibException.Create('element');
-
-  if Supports(AElement, IX9ECParameters, Result) then
-    Exit;
-
-  LSequence := TAsn1Sequence.GetOptional(AElement);
-  if LSequence <> nil then
-    Result := TX9ECParameters.Create(LSequence)
-  else
-    Result := nil;
-end;
-
-function TX9ECParameters.GetN: TBigInteger;
-begin
-  Result := Fn;
-end;
-
-function TX9ECParameters.GetSeed: TCryptoLibByteArray;
-begin
-  Result := Fseed;
-end;
-
-/// * *
-// * Produce an object suitable for an Asn1OutputStream.
-// * <pre>
-// *  ECParameters ::= Sequence {
-// *      version         Integer { ecpVer1(1) } (ecpVer1),
-// *      fieldID         FieldID {{FieldTypes}},
-// *      curve           X9Curve,
-// *      base            X9ECPoint,
-// *      order           Integer,
-// *      cofactor        Integer OPTIONAL
-// *  }
-// * </pre>
-// */
-
-function TX9ECParameters.ToAsn1Object: IAsn1Object;
-var
-  v: IAsn1EncodableVector;
-begin
-
-  v := TAsn1EncodableVector.Create
-    ([TDerInteger.Create(TBigInteger.One) as IDerInteger, FfieldID,
-    TX9Curve.Create(Fcurve, Fseed) as IX9Curve, Fg, TDerInteger.Create(Fn)
-    as IDerInteger]);
-
-  if (Fh.IsInitialized) then
-  begin
-    v.Add([TDerInteger.Create(Fh) as IDerInteger]);
-  end;
-
-  Result := TDerSequence.Create(v);
-
-end;
-
-end.

CryptoLib/src/Asn1/X9/ClpX9ECParametersHolder.pas

@@ -23,7 +23,7 @@ interface
 
 uses
   SyncObjs,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpIX9ECParametersHolder;
 
 type

CryptoLib/src/Asn1/X9/ClpX9IntegerConverter.pas

@@ -0,0 +1,92 @@
+{ *********************************************************************************** }
+{ *                              CryptoLib Library                                  * }
+{ *                Copyright (c) 2018 - 20XX Ugochukwu Mmaduekwe                    * }
+{ *                 Github Repository <https://github.com/Xor-el>                   * }
+
+{ *  Distributed under the MIT software license, see the accompanying file LICENSE  * }
+{ *          or visit http://www.opensource.org/licenses/mit-license.php.           * }
+
+{ *                              Acknowledgements:                                  * }
+{ *                                                                                 * }
+{ *      Thanks to Sphere 10 Software (http://www.sphere10.com/) for sponsoring     * }
+{ *                           development of this library                           * }
+
+{ * ******************************************************************************* * }
+
+(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
+
+unit ClpX9IntegerConverter;
+
+{$I ..\..\Include\CryptoLib.inc}
+
+interface
+
+uses
+  ClpBigInteger,
+  ClpIECC,
+  ClpCryptoLibTypes;
+
+type
+  /// <summary>
+  /// Integer converter for X9.62 encoding.
+  /// </summary>
+  TX9IntegerConverter = class sealed(TObject)
+
+  public
+    /// <summary>
+    /// Get the byte length for a field element.
+    /// </summary>
+    class function GetByteLength(const AFe: IECFieldElement): Int32; overload; static;
+    /// <summary>
+    /// Get the byte length for a curve.
+    /// </summary>
+    class function GetByteLength(const AC: IECCurve): Int32; overload; static;
+    /// <summary>
+    /// Convert an integer to bytes of the specified length.
+    /// </summary>
+    class function IntegerToBytes(const &AS: TBigInteger; AQLength: Int32): TCryptoLibByteArray; static;
+
+  end;
+
+implementation
+
+{ TX9IntegerConverter }
+
+class function TX9IntegerConverter.GetByteLength(const AFe: IECFieldElement): Int32;
+begin
+  Result := AFe.GetEncodedLength();
+end;
+
+class function TX9IntegerConverter.GetByteLength(const AC: IECCurve): Int32;
+begin
+  Result := AC.FieldElementEncodingLength;
+end;
+
+class function TX9IntegerConverter.IntegerToBytes(const &AS: TBigInteger; AQLength: Int32): TCryptoLibByteArray;
+var
+  LBytes, LTmp: TCryptoLibByteArray;
+begin
+  LBytes := &AS.ToByteArrayUnsigned();
+
+  if AQLength < System.Length(LBytes) then
+  begin
+    System.SetLength(LTmp, AQLength);
+    System.Move(LBytes[System.Length(LBytes) - System.Length(LTmp)], LTmp[0],
+      System.Length(LTmp) * System.SizeOf(Byte));
+    Result := LTmp;
+    Exit;
+  end;
+
+  if AQLength > System.Length(LBytes) then
+  begin
+    System.SetLength(LTmp, AQLength);
+    System.Move(LBytes[0], LTmp[System.Length(LTmp) - System.Length(LBytes)],
+      System.Length(LBytes) * System.SizeOf(Byte));
+    Result := LTmp;
+    Exit;
+  end;
+
+  Result := LBytes;
+end;
+
+end.

CryptoLib/src/Crypto/EC/ClpCustomNamedCurves.pas

@@ -47,14 +47,12 @@ uses
   ClpCurve25519Custom,
   ClpICurve25519Custom,
   ClpIECC,
-  ClpX9ECC,
-  ClpIX9ECC,
   ClpIAsn1Objects,
   ClpScalarSplitParameters,
   ClpIScalarSplitParameters,
   ClpGlvTypeBEndomorphism,
-  ClpX9ECParameters,
-  ClpIX9ECParameters,
+  ClpX9ECAsn1Objects,
+  ClpIX9ECAsn1Objects,
   ClpX9ECParametersHolder,
   ClpIX9ECParametersHolder,
   ClpIGlvTypeBParameters;

CryptoLib/src/Crypto/EC/ClpECUtilities.pas

@@ -23,7 +23,7 @@ interface
 
 uses
   ClpIAsn1Objects,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpCustomNamedCurves,
   ClpECNamedCurveTable;
 

CryptoLib/src/Crypto/Generators/ClpECKeyPairGenerator.pas

@@ -41,7 +41,7 @@ uses
   ClpCustomNamedCurves,
   ClpECNamedCurveTable,
   ClpX9ObjectIdentifiers,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpAsymmetricCipherKeyPair,
   ClpIAsymmetricCipherKeyPair,
   ClpECPublicKeyParameters,

CryptoLib/src/Crypto/Parameters/ClpECDomainParameters.pas

@@ -28,12 +28,10 @@ uses
   ClpIECC,
   ClpCryptoLibTypes,
   ClpIECDomainParameters,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpIAsn1Objects,
   ClpIX9Asn1Objects,
-  ClpX9ECParameters,
-  ClpX9ECC,
-  ClpIX9ECC,
+  ClpX9ECAsn1Objects,
   ClpX9Asn1Objects;
 
 resourcestring

CryptoLib/src/Crypto/Parameters/ClpECNamedDomainParameters.pas

@@ -27,7 +27,7 @@ uses
   ClpIECC,
   ClpIECDomainParameters,
   ClpIECNamedDomainParameters,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpX9Asn1Objects,
   ClpIX9Asn1Objects,
   ClpECDomainParameters,

CryptoLib/src/Factories/ClpPrivateKeyFactory.pas

@@ -39,7 +39,7 @@ uses
   ClpX509ObjectIdentifiers,
   ClpX9ObjectIdentifiers,
   ClpX9Asn1Objects,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpPkcsAsn1Objects,
   ClpIECDomainParameters,
   ClpIDsaParameters,

CryptoLib/src/Factories/ClpPublicKeyFactory.pas

@@ -36,7 +36,7 @@ uses
   ClpOiwObjectIdentifiers,
   ClpX9Asn1Objects,
   ClpIX9Asn1Objects,
-  ClpIX9ECParameters,
+  ClpIX9ECAsn1Objects,
   ClpAsn1Objects,
   ClpIECC,
   ClpIECDomainParameters,

CryptoLib/src/Factories/ClpSubjectPublicKeyInfoFactory.pas

@@ -40,8 +40,8 @@ uses
   ClpX509Asn1Objects,
   ClpX9Asn1Objects,
   ClpIX9Asn1Objects,
-  ClpX9ECParameters,
-  ClpIX9ECParameters,
+  ClpX9ECAsn1Objects,
+  ClpIX9ECAsn1Objects,
   ClpCryptoLibTypes;
 
 type

CryptoLib/src/Interfaces/Asn1/X9/ClpIX9ECC.pas → CryptoLib/src/Interfaces/Asn1/X9/ClpIX9ECAsn1Objects.pas

@@ -15,65 +15,96 @@
 
 (* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
 
-unit ClpIX9ECC;
+unit ClpIX9ECAsn1Objects;
 
 {$I ..\..\..\Include\CryptoLib.inc}
 
 interface
 
 uses
-  ClpIECC,
   ClpIAsn1Core,
   ClpIAsn1Objects,
+  ClpBigInteger,
+  ClpIECC,
   ClpCryptoLibTypes;
 
 type
+  /// <summary>
+  /// Interface for X9FieldID.
+  /// </summary>
   IX9FieldID = interface(IAsn1Encodable)
+    ['{8A3B4C5D-6E7F-8901-A2B3-C4D5E6F7A8B9}']
 
-    ['{12A8969E-8050-4BB2-87F7-F4E155A35DCE}']
-
-    function GetIdentifier: IDerObjectIdentifier;
+    function GetFieldType: IDerObjectIdentifier;
     function GetParameters: IAsn1Object;
 
-    property Identifier: IDerObjectIdentifier read GetIdentifier;
-
+    property FieldType: IDerObjectIdentifier read GetFieldType;
     property Parameters: IAsn1Object read GetParameters;
-
   end;
 
-type
+  /// <summary>
+  /// Interface for X9FieldElement.
+  /// </summary>
   IX9FieldElement = interface(IAsn1Encodable)
-    ['{7B055B2C-04BB-438B-B590-9A157F6412C0}']
+    ['{1B2C3D4E-5F6A-7B8C-9D0E-1F2A3B4C5D6E}']
 
     function GetValue: IECFieldElement;
 
     property Value: IECFieldElement read GetValue;
-
   end;
 
-type
+  /// <summary>
+  /// Interface for X9Curve.
+  /// </summary>
+  IX9Curve = interface(IAsn1Encodable)
+    ['{2C3D4E5F-6A7B-8C9D-0E1F-2A3B4C5D6E7F}']
+
+    function GetCurve: IECCurve;
+    function GetSeed: IDerBitString;
+    function GetSeedBytes: TCryptoLibByteArray;
 
+    property Curve: IECCurve read GetCurve;
+    property Seed: IDerBitString read GetSeed;
+  end;
+
+  /// <summary>
+  /// Interface for X9ECPoint.
+  /// </summary>
   IX9ECPoint = interface(IAsn1Encodable)
-    ['{B91190B8-A56A-4231-9687-24E4BB1397C7}']
+    ['{3D4E5F6A-7B8C-9D0E-1F2A-3B4C5D6E7F8A}']
 
-    function GetPointEncoding(): TCryptoLibByteArray;
-    function GetIsPointCompressed: Boolean;
     function GetPoint: IECPoint;
+    function GetPointEncoding: IAsn1OctetString;
+    function GetIsPointCompressed: Boolean;
+
     property Point: IECPoint read GetPoint;
+    property PointEncoding: IAsn1OctetString read GetPointEncoding;
     property IsPointCompressed: Boolean read GetIsPointCompressed;
-
   end;
 
-type
-  IX9Curve = interface(IAsn1Encodable)
-    ['{BD78E2A1-C079-461C-8962-C4834DFA1478}']
+  /// <summary>
+  /// Interface for X9ECParameters.
+  /// </summary>
+  IX9ECParameters = interface(IAsn1Encodable)
+    ['{4E5F6A7B-8C9D-0E1F-2A3B-4C5D6E7F8A9B}']
 
     function GetCurve: IECCurve;
-
-    function GetSeed(): TCryptoLibByteArray;
-
-    property curve: IECCurve read GetCurve;
-
+    function GetG: IECPoint;
+    function GetN: TBigInteger;
+    function GetH: TBigInteger;
+    function GetCurveEntry: IX9Curve;
+    function GetFieldIDEntry: IX9FieldID;
+    function GetBaseEntry: IX9ECPoint;
+
+    function GetSeed: TCryptoLibByteArray;
+
+    property Curve: IECCurve read GetCurve;
+    property G: IECPoint read GetG;
+    property N: TBigInteger read GetN;
+    property H: TBigInteger read GetH;
+    property CurveEntry: IX9Curve read GetCurveEntry;
+    property FieldIDEntry: IX9FieldID read GetFieldIDEntry;
+    property BaseEntry: IX9ECPoint read GetBaseEntry;
   end;
 
 implementation

CryptoLib/src/Interfaces/Asn1/X9/ClpIX9ECParameters.pas

@@ -1,59 +0,0 @@
-{ *********************************************************************************** }
-{ *                              CryptoLib Library                                  * }
-{ *                Copyright (c) 2018 - 20XX Ugochukwu Mmaduekwe                    * }
-{ *                 Github Repository <https://github.com/Xor-el>                   * }
-
-{ *  Distributed under the MIT software license, see the accompanying file LICENSE  * }
-{ *          or visit http://www.opensource.org/licenses/mit-license.php.           * }
-
-{ *                              Acknowledgements:                                  * }
-{ *                                                                                 * }
-{ *      Thanks to Sphere 10 Software (http://www.sphere10.com/) for sponsoring     * }
-{ *                           development of this library                           * }
-
-{ * ******************************************************************************* * }
-
-(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
-
-unit ClpIX9ECParameters;
-
-{$I ..\..\..\Include\CryptoLib.inc}
-
-interface
-
-uses
-  ClpCryptoLibTypes,
-  ClpIAsn1Objects,
-  ClpIAsn1Core,
-  ClpBigInteger,
-  ClpIX9ECC,
-  ClpIECC;
-
-type
-
-  IX9ECParameters = interface(IAsn1Encodable)
-    ['{9D037623-C439-46E8-960B-92E81386D51D}']
-
-    function GetCurve: IECCurve;
-    function GetG: IECPoint;
-    function GetH: TBigInteger;
-    function GetN: TBigInteger;
-    function GetBaseEntry: IX9ECPoint;
-    function GetCurveEntry: IX9Curve;
-    function GetFieldIDEntry: IX9FieldID;
-
-    property Curve: IECCurve read GetCurve;
-    property G: IECPoint read GetG;
-    property N: TBigInteger read GetN;
-    property H: TBigInteger read GetH;
-    property CurveEntry: IX9Curve read GetCurveEntry;
-    property FieldIDEntry: IX9FieldID read GetFieldIDEntry;
-    property BaseEntry: IX9ECPoint read GetBaseEntry;
-
-    function GetSeed(): TCryptoLibByteArray;
-
-  end;
-
-implementation
-
-end.

CryptoLib/src/Interfaces/Asn1/X9/ClpIX9ECParametersHolder.pas

@@ -22,7 +22,7 @@ unit ClpIX9ECParametersHolder;
 interface
 
 uses
-  ClpIX9ECParameters;
+  ClpIX9ECAsn1Objects;
 
 type
   IX9ECParametersHolder = interface(IInterface)

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

@@ -26,7 +26,7 @@ uses
   ClpIECC,
   ClpCryptoLibTypes,
   ClpIX9Asn1Objects,
-  ClpIX9ECParameters;
+  ClpIX9ECAsn1Objects;
 
 type
   IECDomainParameters = interface(IInterface)

CryptoLib/src/Interfaces/Math/EC/ClpIECC.pas

@@ -72,6 +72,7 @@ type
     function ToString(): String;
 
     function GetEncoded(): TCryptoLibByteArray;
+    function GetEncodedLength(): Int32;
 
     property FieldName: string read GetFieldName;
     property FieldSize: Int32 read GetFieldSize;
@@ -458,7 +459,10 @@ type
 
     function DecompressPoint(yTilde: Int32; const x1: TBigInteger): IECPoint;
 
+    function GetFieldElementEncodingLength: Int32;
+
     property FieldSize: Int32 read GetFieldSize;
+    property FieldElementEncodingLength: Int32 read GetFieldElementEncodingLength;
     function FromBigInteger(const x: TBigInteger): IECFieldElement;
     function IsValidFieldElement(const x: TBigInteger): Boolean;
 

CryptoLib/src/Math/EC/ClpECC.pas

@@ -155,6 +155,7 @@ type
     function ToString(): String; override;
 
     function GetEncoded(): TCryptoLibByteArray; virtual;
+    function GetEncodedLength(): Int32; virtual;
 
     property FieldName: string read GetFieldName;
     property FieldSize: Int32 read GetFieldSize;
@@ -502,6 +503,7 @@ type
     function GetOrder: TBigInteger; virtual;
     function GetCofactor: TBigInteger; virtual;
     function GetCoordinateSystem: Int32; virtual;
+    function GetFieldElementEncodingLength: Int32; virtual;
 
     function GetFieldSize: Int32; virtual; abstract;
     function GetInfinity: IECPoint; virtual; abstract;
@@ -1903,10 +1905,15 @@ end;
 
 function TECFieldElement.GetEncoded: TCryptoLibByteArray;
 begin
-  result := TBigIntegers.AsUnsignedByteArray((FieldSize + 7) div 8,
+  result := TBigIntegers.AsUnsignedByteArray(GetEncodedLength(),
     ToBigInteger());
 end;
 
+function TECFieldElement.GetEncodedLength: Int32;
+begin
+  Result := (FieldSize + 7) div 8;
+end;
+
 function TECFieldElement.GetHashCode: {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}
 begin
@@ -2614,6 +2621,11 @@ begin
     Self.Fm_endomorphism, Self.Fm_multiplier);
 end;
 
+function TECCurve.GetFieldElementEncodingLength: Int32;
+begin
+  Result := (FieldSize + 7) div 8;
+end;
+
 constructor TECCurve.Create(const field: IFiniteField);
 begin
   inherited Create();