Some refactoring.

CryptoLib.Tests/src/Asn1/Asn1SequenceParserTests.pas

@@ -216,9 +216,10 @@ begin
   try
     seqGen := TBerSequenceGenerator.Create(bOut, 1, true);
 
-    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen.Close();
 
@@ -281,9 +282,10 @@ begin
   try
     seqGen := TBerSequenceGenerator.Create(bOut);
 
-    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen.Close();
     bOut.Position := 0;
@@ -306,9 +308,10 @@ begin
   try
     seqGen := TDerSequenceGenerator.Create(bOut, 1, true);
 
-    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen.Close();
 
@@ -333,9 +336,10 @@ begin
   try
     seqGen := TDerSequenceGenerator.Create(bOut, 1, false);
 
-    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen.Close();
 
@@ -398,9 +402,10 @@ begin
   try
     seqGen := TDerSequenceGenerator.Create(bOut);
 
-    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen.Close();
     bOut.Position := 0;
@@ -429,13 +434,15 @@ begin
   try
     seqGen1 := TBerSequenceGenerator.Create(bOut);
 
-    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen2 := TDerSequenceGenerator.Create(seqGen1.GetRawOutputStream());
 
-    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1)));
+    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1))
+      as IDerInteger);
 
     seqGen2.Close();
 
@@ -466,9 +473,10 @@ begin
   try
     seqGen1 := TBerSequenceGenerator.Create(bOut);
 
-    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen2 := TBerSequenceGenerator.Create(seqGen1.GetRawOutputStream());
 
@@ -503,13 +511,14 @@ begin
   try
     seqGen1 := TDerSequenceGenerator.Create(bOut);
 
-    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen2 := TDerSequenceGenerator.Create(seqGen1.GetRawOutputStream());
 
-    seqGen2.AddObject(TDerInteger.Create(TBigInteger.One));
+    seqGen2.AddObject(TDerInteger.Create(TBigInteger.One) as IDerInteger);
 
     seqGen2.Close();
 
@@ -535,14 +544,16 @@ begin
   try
     seqGen1 := TDerSequenceGenerator.Create(bOut);
 
-    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen2 := TDerSequenceGenerator.Create
       (seqGen1.GetRawOutputStream(), 1, true);
 
-    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1)));
+    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1))
+      as IDerInteger);
 
     seqGen2.Close();
 
@@ -568,14 +579,16 @@ begin
   try
     seqGen1 := TDerSequenceGenerator.Create(bOut);
 
-    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero));
+    seqGen1.AddObject(TDerInteger.Create(TBigInteger.Zero) as IDerInteger);
 
-    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1'));
+    seqGen1.AddObject(TDerObjectIdentifier.Create('1.1')
+      as IDerObjectIdentifier);
 
     seqGen2 := TDerSequenceGenerator.Create(seqGen1.GetRawOutputStream(),
       1, false);
 
-    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1)));
+    seqGen2.AddObject(TDerInteger.Create(TBigInteger.ValueOf(1))
+      as IDerInteger);
 
     seqGen2.Close();
 

CryptoLib.Tests/src/Asn1/EqualsAndHashCodeTests.pas

@@ -66,6 +66,7 @@ uses
   ClpAsn1OutputStream,
   ClpAsn1InputStream,
   ClpIAsn1InputStream,
+  ClpIDerPrintableString,
   ClpAsn1Object;
 
 type
@@ -122,14 +123,20 @@ begin
     TDerGraphicString.Create(THex.Decode('deadbeef')),
     TDerVideotexString.Create(TEncoding.ASCII.GetBytes('Hello World')),
 
-    TBerTaggedObject.Create(0, TDerPrintableString.Create('hello world')),
+    TBerTaggedObject.Create(0, TDerPrintableString.Create('hello world')
+    as IDerPrintableString),
 
-    TDerTaggedObject.Create(0, TDerPrintableString.Create('hello world')),
+    TDerTaggedObject.Create(0, TDerPrintableString.Create('hello world')
+    as IDerPrintableString),
     //
-    TBerSequence.Create(TDerPrintableString.Create('hello world')),
-    TBerSet.Create(TDerPrintableString.Create('hello world')),
-    TDerSequence.Create(TDerPrintableString.Create('hello world')),
-    TDerSet.Create(TDerPrintableString.Create('hello world'))
+    TBerSequence.Create(TDerPrintableString.Create('hello world')
+    as IDerPrintableString),
+    TBerSet.Create(TDerPrintableString.Create('hello world')
+    as IDerPrintableString),
+    TDerSequence.Create(TDerPrintableString.Create('hello world')
+    as IDerPrintableString),
+    TDerSet.Create(TDerPrintableString.Create('hello world')
+    as IDerPrintableString)
 
     );
 

CryptoLib.Tests/src/Asn1/OIDTests.pas

@@ -88,9 +88,9 @@ end;
 
 procedure TTestOID.constructorMethod;
 var
-temp: IDerObjectIdentifier;
+  temp: IDerObjectIdentifier;
 begin
- temp := TDerObjectIdentifier.Create(Foid);
+  temp := TDerObjectIdentifier.Create(Foid);
 end;
 
 procedure TTestOID.invalidOidCheck;

CryptoLib.Tests/src/Math/BigIntegerTests.pas

@@ -64,7 +64,8 @@ type
 
     function val(n: Int64): TBigInteger;
     function mersenne(e: Int32): TBigInteger;
-    procedure CheckEqualsBigInteger(a, b: TBigInteger; const msg: String = '');
+    procedure CheckEqualsBigInteger(const a, b: TBigInteger;
+      const msg: String = '');
 
   protected
     procedure SetUp; override;
@@ -122,8 +123,8 @@ begin
   result := TBigInteger.ValueOf(n);
 end;
 
-procedure TTestBigInteger.CheckEqualsBigInteger(a, b: TBigInteger;
-  const msg: String);
+procedure TTestBigInteger.CheckEqualsBigInteger(const a, b: TBigInteger;
+  const msg: String = '');
 begin
   CheckEquals(True, a.Equals(b), msg);
 end;

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

@@ -58,8 +58,8 @@ type
     FDP: IX9ECParameters;
     FQ: TBigInteger;
 
-    procedure AssertAreBigIntegersEqual(a, b: TBigInteger);
-    function FE(x: TBigInteger): IECFieldElement;
+    procedure AssertAreBigIntegersEqual(const a, b: TBigInteger);
+    function FE(const x: TBigInteger): IECFieldElement;
     function GenerateMultiplyInput_Random(): IECFieldElement;
     function GenerateSquareInput_CarryBug(): IECFieldElement;
     function Nat_Create(len: Int32): TCryptoLibUInt32Array;
@@ -88,12 +88,13 @@ implementation
 
 { TTestSecP384R1Field }
 
-procedure TTestSecP384R1Field.AssertAreBigIntegersEqual(a, b: TBigInteger);
+procedure TTestSecP384R1Field.AssertAreBigIntegersEqual(const a,
+  b: TBigInteger);
 begin
   CheckEquals(True, a.Equals(b));
 end;
 
-function TTestSecP384R1Field.FE(x: TBigInteger): IECFieldElement;
+function TTestSecP384R1Field.FE(const x: TBigInteger): IECFieldElement;
 begin
   result := FDP.Curve.FromBigInteger(x);
 end;

CryptoLib.Tests/src/Math/ECAlgorithmsTests.pas

@@ -64,20 +64,21 @@ type
   const
     Scale = Int32(4);
 
-    procedure DoTestSumOfMultiplies(x9: IX9ECParameters);
-    procedure DoTestSumOfTwoMultiplies(x9: IX9ECParameters);
-    procedure AssertPointsEqual(const msg: String; a, b: IECPoint);
+    procedure DoTestSumOfMultiplies(const x9: IX9ECParameters);
+    procedure DoTestSumOfTwoMultiplies(const x9: IX9ECParameters);
+    procedure AssertPointsEqual(const msg: String; const a, b: IECPoint);
     function CopyPoints(ps: TCryptoLibGenericArray<IECPoint>; len: Int32)
       : TCryptoLibGenericArray<IECPoint>;
     function CopyScalars(ks: TCryptoLibGenericArray<TBigInteger>; len: Int32)
       : TCryptoLibGenericArray<TBigInteger>;
 
-    function GetRandomPoint(x9: IX9ECParameters): IECPoint;
-    function GetRandomScalar(x9: IX9ECParameters): TBigInteger;
+    function GetRandomPoint(const x9: IX9ECParameters): IECPoint;
+    function GetRandomScalar(const x9: IX9ECParameters): TBigInteger;
 
     function GetTestCurves(): TCryptoLibGenericArray<IX9ECParameters>;
 
-    procedure AddTestCurves(x9s: TList<IX9ECParameters>; x9: IX9ECParameters);
+    procedure AddTestCurves(x9s: TList<IX9ECParameters>;
+      const x9: IX9ECParameters);
 
   protected
     procedure SetUp; override;
@@ -95,7 +96,7 @@ implementation
 { TTestECAlgorithms }
 
 procedure TTestECAlgorithms.AddTestCurves(x9s: TList<IX9ECParameters>;
-  x9: IX9ECParameters);
+  const x9: IX9ECParameters);
 var
   curve, c: IECCurve;
   coord, i: Int32;
@@ -115,13 +116,14 @@ begin
     else if (curve.SupportsCoordinateSystem(coord)) then
     begin
       c := curve.Configure().SetCoordinateSystem(coord).CreateCurve();
-      x9s.Add(TX9ECParameters.Create(c, c.ImportPoint(x9.G), x9.N, x9.H));
+      x9s.Add(TX9ECParameters.Create(c, c.ImportPoint(x9.G), x9.N, x9.H)
+        as IX9ECParameters);
     end;
   end;
 end;
 
 procedure TTestECAlgorithms.AssertPointsEqual(const msg: String;
-  a, b: IECPoint);
+  const a, b: IECPoint);
 begin
   CheckEquals(True, a.Equals(b), msg);
 end;
@@ -140,7 +142,7 @@ begin
   Result := System.Copy(ks, 0, len);
 end;
 
-procedure TTestECAlgorithms.DoTestSumOfMultiplies(x9: IX9ECParameters);
+procedure TTestECAlgorithms.DoTestSumOfMultiplies(const x9: IX9ECParameters);
 var
   points, results: TCryptoLibGenericArray<IECPoint>;
   scalars: TCryptoLibGenericArray<TBigInteger>;
@@ -172,9 +174,10 @@ begin
     AssertPointsEqual('ECAlgorithms.SumOfMultiplies is incorrect', results[0],
       results[1]);
   end;
+
 end;
 
-procedure TTestECAlgorithms.DoTestSumOfTwoMultiplies(x9: IX9ECParameters);
+procedure TTestECAlgorithms.DoTestSumOfTwoMultiplies(const x9: IX9ECParameters);
 var
   i: Int32;
   p, q, u, v, w: IECPoint;
@@ -208,12 +211,13 @@ begin
   end;
 end;
 
-function TTestECAlgorithms.GetRandomPoint(x9: IX9ECParameters): IECPoint;
+function TTestECAlgorithms.GetRandomPoint(const x9: IX9ECParameters): IECPoint;
 begin
   Result := x9.G.Multiply(GetRandomScalar(x9));
 end;
 
-function TTestECAlgorithms.GetRandomScalar(x9: IX9ECParameters): TBigInteger;
+function TTestECAlgorithms.GetRandomScalar(const x9: IX9ECParameters)
+  : TBigInteger;
 begin
   Result := TBigInteger.Create(x9.N.BitLength, FRandom);
 end;

CryptoLib.Tests/src/Math/ECPointTests.pas

@@ -112,13 +112,13 @@ type
     FpInstance: TFp;
     F2mInstance: TF2m;
 
-    procedure AssertPointsEqual(const msg: String; a, b: IECPoint);
+    procedure AssertPointsEqual(const msg: String; const a, b: IECPoint);
     // procedure AssertBigIntegersEqual(a, b: TBigInteger);
     // procedure AssertIFiniteFieldsEqual(a, b: IFiniteField);
     // procedure AssertOptionalValuesAgree(a, b: TBigInteger); overload;
     // procedure AssertOptionalValuesAgree(a, b: TCryptoLibByteArray); overload;
 
-    procedure AssertECFieldElementsEqual(a, b: IECFieldElement);
+    procedure AssertECFieldElementsEqual(const a, b: IECFieldElement);
 
     // /**
     // * Tests <code>ECPoint.add()</code> against literature values.
@@ -129,7 +129,7 @@ type
     // *            The point at infinity on the respective curve.
     // */
     procedure ImplTestAdd(p: TCryptoLibGenericArray<IECPoint>;
-      infinity: IECPoint);
+      const infinity: IECPoint);
 
     // /**
     // * Tests <code>ECPoint.twice()</code> against literature values.
@@ -152,7 +152,7 @@ type
     // * @param infinity
     // *            The point at infinity on the elliptic curve.
     // */
-    procedure ImplTestAllPoints(p, infinity: IECPoint);
+    procedure ImplTestAllPoints(const p, infinity: IECPoint);
     // /**
     // * Checks, if the point multiplication algorithm of the given point yields
     // * the same result as point multiplication done by the reference
@@ -165,7 +165,7 @@ type
     // *            The bitlength of the random number by which <code>p</code>
     // *            is multiplied.
     // */
-    procedure ImplTestMultiply(p: IECPoint; numBits: Int32);
+    procedure ImplTestMultiply(const p: IECPoint; numBits: Int32);
     // /**
     // * Checks, if the point multiplication algorithm of the given point yields
     // * the same result as point multiplication done by the reference
@@ -178,7 +178,7 @@ type
     // * @param numBits
     // *            Try every multiplier up to this bitlength
     // */
-    procedure ImplTestMultiplyAll(p: IECPoint; numBits: Int32);
+    procedure ImplTestMultiplyAll(const p: IECPoint; numBits: Int32);
     // /**
     // * Tests <code>ECPoint.add()</code> and <code>ECPoint.subtract()</code>
     // * for the given point and the given point at infinity.
@@ -188,22 +188,22 @@ type
     // * @param infinity
     // *            The point at infinity on the same curve as <code>p</code>.
     // */
-    procedure ImplTestAddSubtract(p, infinity: IECPoint);
+    procedure ImplTestAddSubtract(const p, infinity: IECPoint);
     // /**
     // * Test encoding with and without point compression.
     // *
     // * @param p
     // *            The point to be encoded and decoded.
     // */
-    procedure ImplTestEncoding(p: IECPoint);
+    procedure ImplTestEncoding(const p: IECPoint);
 
-    procedure ImplAddSubtractMultiplyTwiceEncodingTest(curve: IECCurve;
-      q: IECPoint; n: TBigInteger);
+    procedure ImplAddSubtractMultiplyTwiceEncodingTest(const curve: IECCurve;
+      const q: IECPoint; const n: TBigInteger);
 
-    procedure ImplSqrtTest(c: IECCurve);
+    procedure ImplSqrtTest(const c: IECCurve);
 
     procedure ImplAddSubtractMultiplyTwiceEncodingTestAllCoords
-      (x9ECParameters: IX9ECParameters);
+      (const x9ECParameters: IX9ECParameters);
 
   protected
     procedure SetUp; override;
@@ -256,7 +256,7 @@ implementation
 
 { TTestECPoint }
 
-procedure TTestECPoint.AssertECFieldElementsEqual(a, b: IECFieldElement);
+procedure TTestECPoint.AssertECFieldElementsEqual(const a, b: IECFieldElement);
 begin
   CheckEquals(True, a.Equals(b));
 end;
@@ -287,14 +287,15 @@ end;
 // end;
 // end;
 
-procedure TTestECPoint.AssertPointsEqual(const msg: String; a, b: IECPoint);
+procedure TTestECPoint.AssertPointsEqual(const msg: String;
+  const a, b: IECPoint);
 begin
   CheckEquals(True, a.Equals(b), msg);
   CheckEquals(True, b.Equals(a), msg);
 end;
 
-procedure TTestECPoint.ImplAddSubtractMultiplyTwiceEncodingTest(curve: IECCurve;
-  q: IECPoint; n: TBigInteger);
+procedure TTestECPoint.ImplAddSubtractMultiplyTwiceEncodingTest
+  (const curve: IECCurve; const q: IECPoint; const n: TBigInteger);
 var
   infinity, p: IECPoint;
   i: Int32;
@@ -317,7 +318,7 @@ begin
 end;
 
 procedure TTestECPoint.ImplAddSubtractMultiplyTwiceEncodingTestAllCoords
-  (x9ECParameters: IX9ECParameters);
+  (const x9ECParameters: IX9ECParameters);
 var
   n, b: TBigInteger;
   G, sg, q: IECPoint;
@@ -358,7 +359,7 @@ begin
   end;
 end;
 
-procedure TTestECPoint.ImplSqrtTest(c: IECCurve);
+procedure TTestECPoint.ImplSqrtTest(const c: IECCurve);
 var
   p, pMinusOne, legendreExponent, nonSquare, x: TBigInteger;
   m, count, i: Int32;
@@ -402,7 +403,7 @@ begin
 end;
 
 procedure TTestECPoint.ImplTestAdd(p: TCryptoLibGenericArray<IECPoint>;
-  infinity: IECPoint);
+  const infinity: IECPoint);
 var
   i: Int32;
 begin
@@ -415,7 +416,7 @@ begin
   end;
 end;
 
-procedure TTestECPoint.ImplTestAddSubtract(p, infinity: IECPoint);
+procedure TTestECPoint.ImplTestAddSubtract(const p, infinity: IECPoint);
 begin
   AssertPointsEqual('Twice and Add inconsistent', p.Twice(), p.Add(p));
   AssertPointsEqual('Twice p - p is not p', p, p.Twice().Subtract(p));
@@ -429,7 +430,7 @@ begin
     infinity.Twice());
 end;
 
-procedure TTestECPoint.ImplTestAllPoints(p, infinity: IECPoint);
+procedure TTestECPoint.ImplTestAllPoints(const p, infinity: IECPoint);
 var
   adder, multiplier: IECPoint;
   i: TBigInteger;
@@ -449,7 +450,7 @@ begin
 
 end;
 
-procedure TTestECPoint.ImplTestEncoding(p: IECPoint);
+procedure TTestECPoint.ImplTestEncoding(const p: IECPoint);
 var
   unCompBarr, compBarr: TCryptoLibByteArray;
   decUnComp, decComp: IECPoint;
@@ -465,7 +466,7 @@ begin
   AssertPointsEqual('Error decoding compressed point', p, decComp);
 end;
 
-procedure TTestECPoint.ImplTestMultiply(p: IECPoint; numBits: Int32);
+procedure TTestECPoint.ImplTestMultiply(const p: IECPoint; numBits: Int32);
 var
   k: TBigInteger;
   reff, q: IECPoint;
@@ -476,7 +477,7 @@ begin
   AssertPointsEqual('ECPoint.Multiply is incorrect', reff, q);
 end;
 
-procedure TTestECPoint.ImplTestMultiplyAll(p: IECPoint; numBits: Int32);
+procedure TTestECPoint.ImplTestMultiplyAll(const p: IECPoint; numBits: Int32);
 var
   bound, k: TBigInteger;
   reff, q: IECPoint;

CryptoLib.Tests/src/Others/ECDsa5Tests.pas

@@ -361,7 +361,8 @@ begin
     // n
     TBigInteger.One); // 1); // h
 
-  g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create()));
+  g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create()
+    as ISecureRandom));
 
   p := g.GenerateKeyPair();
 

CryptoLib.Tests/src/Others/NamedCurveTests.pas

@@ -31,6 +31,7 @@ uses
   TestFramework,
 {$ENDIF FPC}
   ClpSecureRandom,
+  ClpISecureRandom,
   ClpISigner,
   ClpSecNamedCurves,
   ClpIX9ECParameters,
@@ -87,7 +88,8 @@ begin
 
   g := TECKeyPairGenerator.Create('ECDSA');
 
-  g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create()));
+  g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create()
+    as ISecureRandom));
 
   sgr := TSignerUtilities.GetSigner('ECDSA');
   pair := g.GenerateKeyPair();
@@ -139,7 +141,7 @@ end;
 //
 // g := TECKeyPairGenerator.Create(keyAlgorithm);
 //
-// g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create()));
+// g.Init(TECKeyGenerationParameters.Create(ecSpec, TSecureRandom.Create() as ISecureRandom));
 //
 // pair := g.GenerateKeyPair();
 // sKey := pair.Private;

CryptoLib.Tests/src/Others/SignerUtilitiesTests.pas

@@ -133,8 +133,8 @@ begin
     Fcurve.FromBigInteger(FECParraGY)), FECParraN);
 
   FecPub := TECPublicKeyParameters.Create(TFpPoint.Create(Fcurve,
-    Fcurve.FromBigInteger(FECPubQX), Fcurve.FromBigInteger(FECPubQY)),
-    FecDomain);
+    Fcurve.FromBigInteger(FECPubQX), Fcurve.FromBigInteger(FECPubQY))
+    as IFpPoint, FecDomain);
 
   FecPriv := TECPrivateKeyParameters.Create(FECPrivD, FecDomain);
 

CryptoLib.Tests/src/Security/SecureRandomTests.pas

@@ -54,9 +54,10 @@ type
   TTestSecureRandom = class(TCryptoLibTestCase)
   private
 
-    procedure CheckSecureRandom(random: ISecureRandom);
-    function RunChiSquaredTests(random: ISecureRandom): Boolean;
-    function MeasureChiSquared(random: ISecureRandom; rounds: Int32): Double;
+    procedure CheckSecureRandom(const random: ISecureRandom);
+    function RunChiSquaredTests(const random: ISecureRandom): Boolean;
+    function MeasureChiSquared(const random: ISecureRandom;
+      rounds: Int32): Double;
 
   protected
     procedure SetUp; override;
@@ -73,7 +74,7 @@ implementation
 
 { TTestSecureRandom }
 
-procedure TTestSecureRandom.CheckSecureRandom(random: ISecureRandom);
+procedure TTestSecureRandom.CheckSecureRandom(const random: ISecureRandom);
 begin
   // Note: This will periodically (< 1e-6 probability) give a false alarm.
   // That's randomness for you!
@@ -81,7 +82,7 @@ begin
     'Chi2 test detected possible non-randomness');
 end;
 
-function TTestSecureRandom.MeasureChiSquared(random: ISecureRandom;
+function TTestSecureRandom.MeasureChiSquared(const random: ISecureRandom;
   rounds: Int32): Double;
 var
   opts, bs: TCryptoLibByteArray;
@@ -161,7 +162,8 @@ begin
   result := chi2;
 end;
 
-function TTestSecureRandom.RunChiSquaredTests(random: ISecureRandom): Boolean;
+function TTestSecureRandom.RunChiSquaredTests(const random
+  : ISecureRandom): Boolean;
 var
   passes, tries: Int32;
   chi2: Double;

CryptoLib.Tests/src/Utils/ClpFixedSecureRandom.pas

@@ -343,8 +343,8 @@ begin
   FANDROID := TBigInteger.Create('1111111105060708ffffffff01020304', 16);
   FCLASSPATH := TBigInteger.Create('3020104ffffffff05060708111111', 16);
 
-  Fcheck1 := TBigInteger.Create(128, TRandomChecker.Create());
-  Fcheck2 := TBigInteger.Create(120, TRandomChecker.Create());
+  Fcheck1 := TBigInteger.Create(128, TRandomChecker.Create() as ISecureRandom);
+  Fcheck2 := TBigInteger.Create(120, TRandomChecker.Create() as ISecureRandom);
 
   FisAndroidStyle := Fcheck1.Equals(FANDROID);
   FisRegularStyle := Fcheck1.Equals(FREGULAR);

CryptoLib/src/Asn1/ClpAsn1Encodable.pas

@@ -51,7 +51,7 @@ type
     /// </returns>
     function GetDerEncoded(): TCryptoLibByteArray;
 
-    function Equals(other: IAsn1Convertible): Boolean; reintroduce;
+    function Equals(const other: IAsn1Convertible): Boolean; reintroduce;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -63,7 +63,7 @@ implementation
 
 { TAsn1Encodable }
 
-function TAsn1Encodable.Equals(other: IAsn1Convertible): Boolean;
+function TAsn1Encodable.Equals(const other: IAsn1Convertible): Boolean;
 var
   o1, o2: IAsn1Object;
 begin

CryptoLib/src/Asn1/ClpAsn1Generator.pas

@@ -40,7 +40,7 @@ type
     property &Out: TStream read GetOut;
 
   public
-    procedure AddObject(obj: IAsn1Encodable); virtual; abstract;
+    procedure AddObject(const obj: IAsn1Encodable); virtual; abstract;
 
     function GetRawOutputStream(): TStream; virtual; abstract;
 

CryptoLib/src/Asn1/ClpAsn1InputStream.pas

@@ -133,13 +133,14 @@ type
 
     function BuildEncodableVector(): IAsn1EncodableVector;
 
-    function BuildDerEncodableVector(dIn: IDefiniteLengthInputStream)
+    function BuildDerEncodableVector(const dIn: IDefiniteLengthInputStream)
       : IAsn1EncodableVector; virtual;
 
-    function CreateDerSequence(dIn: IDefiniteLengthInputStream)
+    function CreateDerSequence(const dIn: IDefiniteLengthInputStream)
       : IDerSequence; virtual;
 
-    function CreateDerSet(dIn: IDefiniteLengthInputStream): IDerSet; virtual;
+    function CreateDerSet(const dIn: IDefiniteLengthInputStream)
+      : IDerSet; virtual;
 
     class function FindLimit(input: TStream): Int32; static;
 
@@ -147,12 +148,12 @@ type
 
     class function ReadLength(s: TStream; limit: Int32): Int32; static;
 
-    class function GetBuffer(defIn: IDefiniteLengthInputStream;
+    class function GetBuffer(const defIn: IDefiniteLengthInputStream;
       tmpBuffers: TCryptoLibMatrixGenericArray<Byte>): TCryptoLibByteArray;
       static; inline;
 
     class function CreatePrimitiveDerObject(tagNo: Int32;
-      defIn: IDefiniteLengthInputStream;
+      const defIn: IDefiniteLengthInputStream;
       tmpBuffers: TCryptoLibMatrixGenericArray<Byte>): IAsn1Object; static;
   end;
 
@@ -197,8 +198,9 @@ begin
   result := System.High(Int32);
 end;
 
-class function TAsn1InputStream.GetBuffer(defIn: IDefiniteLengthInputStream;
-  tmpBuffers: TCryptoLibMatrixGenericArray<Byte>): TCryptoLibByteArray;
+class function TAsn1InputStream.GetBuffer(const defIn
+  : IDefiniteLengthInputStream; tmpBuffers: TCryptoLibMatrixGenericArray<Byte>)
+  : TCryptoLibByteArray;
 var
   len: Int32;
   buf, temp: TCryptoLibByteArray;
@@ -224,7 +226,7 @@ begin
 end;
 
 class function TAsn1InputStream.CreatePrimitiveDerObject(tagNo: Int32;
-  defIn: IDefiniteLengthInputStream;
+  const defIn: IDefiniteLengthInputStream;
   tmpBuffers: TCryptoLibMatrixGenericArray<Byte>): IAsn1Object;
 var
   bytes: TCryptoLibByteArray;
@@ -539,7 +541,7 @@ begin
 end;
 
 function TAsn1InputStream.BuildDerEncodableVector
-  (dIn: IDefiniteLengthInputStream): IAsn1EncodableVector;
+  (const dIn: IDefiniteLengthInputStream): IAsn1EncodableVector;
 var
   res: TAsn1InputStream;
 begin
@@ -670,14 +672,14 @@ begin
 
 end;
 
-function TAsn1InputStream.CreateDerSequence(dIn: IDefiniteLengthInputStream)
-  : IDerSequence;
+function TAsn1InputStream.CreateDerSequence
+  (const dIn: IDefiniteLengthInputStream): IDerSequence;
 begin
   result := TDerSequence.FromVector(BuildDerEncodableVector(dIn));
 end;
 
-function TAsn1InputStream.CreateDerSet(dIn: IDefiniteLengthInputStream)
-  : IDerSet;
+function TAsn1InputStream.CreateDerSet(const dIn
+  : IDefiniteLengthInputStream): IDerSet;
 begin
   result := TDerSet.FromVector(BuildDerEncodableVector(dIn), false);
 end;

CryptoLib/src/Asn1/ClpAsn1Object.pas

@@ -39,7 +39,8 @@ type
 
   strict protected
 
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; virtual; abstract;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean;
+      virtual; abstract;
 
     function Asn1GetHashCode(): Int32; virtual; abstract;
 
@@ -61,9 +62,9 @@ type
 
     function ToAsn1Object(): IAsn1Object; override;
 
-    procedure Encode(derOut: IDerOutputStream); virtual; abstract;
+    procedure Encode(const derOut: IDerOutputStream); virtual; abstract;
 
-    function CallAsn1Equals(obj: IAsn1Object): Boolean;
+    function CallAsn1Equals(const obj: IAsn1Object): Boolean;
 
     function CallAsn1GetHashCode(): Int32;
 
@@ -77,7 +78,7 @@ uses
 
 { TAsn1Object }
 
-function TAsn1Object.CallAsn1Equals(obj: IAsn1Object): Boolean;
+function TAsn1Object.CallAsn1Equals(const obj: IAsn1Object): Boolean;
 begin
   result := Asn1Equals(obj);
 end;

CryptoLib/src/Asn1/ClpAsn1OctetString.pas

@@ -53,7 +53,7 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
     property Str: TCryptoLibByteArray read GetStr;
@@ -72,8 +72,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IAsn1OctetString; overload; static;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IAsn1OctetString; overload; static;
     /// <summary>
     /// return an Octet string from the given object.
     /// </summary>
@@ -91,7 +91,7 @@ type
     /// </param>
     constructor Create(Str: TCryptoLibByteArray); overload;
 
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     function GetOctetStream(): TStream;
 
@@ -119,7 +119,7 @@ begin
   FStr := Str;
 end;
 
-function TAsn1OctetString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TAsn1OctetString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerOctetString;
 begin
@@ -138,7 +138,7 @@ begin
   result := TArrayUtils.GetArrayHashCode(GetOctets());
 end;
 
-constructor TAsn1OctetString.Create(obj: IAsn1Encodable);
+constructor TAsn1OctetString.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create();
   try
@@ -152,7 +152,7 @@ begin
   end;
 end;
 
-class function TAsn1OctetString.GetInstance(obj: IAsn1TaggedObject;
+class function TAsn1OctetString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IAsn1OctetString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpAsn1Sequence.pas

@@ -67,7 +67,7 @@ type
       Fmax, Findex: Int32;
 
     public
-      constructor Create(outer: IAsn1Sequence);
+      constructor Create(const outer: IAsn1Sequence);
       function ReadObject(): IAsn1Convertible;
       function ToAsn1Object(): IAsn1Object;
 
@@ -75,8 +75,8 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
-    procedure AddObject(obj: IAsn1Encodable); inline;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
+    procedure AddObject(const obj: IAsn1Encodable); inline;
 
     constructor Create(capacity: Int32);
 
@@ -135,8 +135,8 @@ type
     // * @exception ArgumentException if the tagged object cannot
     // *          be converted.
     // */
-    class function GetInstance(obj: IAsn1TaggedObject; explicitly: Boolean)
-      : IAsn1Sequence; overload; static;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      explicitly: Boolean): IAsn1Sequence; overload; static;
 
     property Parser: IAsn1SequenceParser read GetParser;
     property Count: Int32 read GetCount;
@@ -169,12 +169,12 @@ begin
   result := encObj;
 end;
 
-procedure TAsn1Sequence.AddObject(obj: IAsn1Encodable);
+procedure TAsn1Sequence.AddObject(const obj: IAsn1Encodable);
 begin
   FSeq.Add(obj);
 end;
 
-function TAsn1Sequence.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TAsn1Sequence.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IAsn1Sequence;
   s1, s2: TEnumerator<IAsn1Encodable>;
@@ -197,19 +197,25 @@ begin
   s1 := GetEnumerator;
   s2 := other.GetEnumerator;
 
-  while (s1.MoveNext() and s2.MoveNext()) do
-  begin
-    o1 := GetCurrent(s1).ToAsn1Object();
-    o2 := GetCurrent(s2).ToAsn1Object();
-
-    if (not(o1.Equals(o2))) then
+  try
+    while (s1.MoveNext() and s2.MoveNext()) do
     begin
-      result := false;
-      Exit;
+      o1 := GetCurrent(s1).ToAsn1Object();
+      o2 := GetCurrent(s2).ToAsn1Object();
+
+      if (not(o1.Equals(o2))) then
+      begin
+        result := false;
+        Exit;
+      end;
     end;
+
+    result := true;
+  finally
+    s1.Free;
+    s2.Free;
   end;
 
-  result := true;
 end;
 
 function TAsn1Sequence.Asn1GetHashCode: Int32;
@@ -309,7 +315,7 @@ begin
   end;
 end;
 
-class function TAsn1Sequence.GetInstance(obj: IAsn1TaggedObject;
+class function TAsn1Sequence.GetInstance(const obj: IAsn1TaggedObject;
   explicitly: Boolean): IAsn1Sequence;
 var
   inner: IAsn1Object;
@@ -370,7 +376,8 @@ end;
 
 { TAsn1Sequence.TAsn1SequenceParserImpl }
 
-constructor TAsn1Sequence.TAsn1SequenceParserImpl.Create(outer: IAsn1Sequence);
+constructor TAsn1Sequence.TAsn1SequenceParserImpl.Create
+  (const outer: IAsn1Sequence);
 begin
   inherited Create();
   Fouter := outer;

CryptoLib/src/Asn1/ClpAsn1Set.pas

@@ -73,7 +73,7 @@ type
       Fmax, Findex: Int32;
 
     public
-      constructor Create(outer: IAsn1Set);
+      constructor Create(const outer: IAsn1Set);
       function ReadObject(): IAsn1Convertible;
       function ToAsn1Object(): IAsn1Object;
 
@@ -81,8 +81,8 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
-    procedure AddObject(obj: IAsn1Encodable); inline;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
+    procedure AddObject(const obj: IAsn1Encodable); inline;
     procedure Sort();
 
     constructor Create(capacity: Int32);
@@ -145,8 +145,8 @@ type
     // * @exception ArgumentException if the tagged object cannot
     // *          be converted.
     // */
-    class function GetInstance(obj: IAsn1TaggedObject; explicitly: Boolean)
-      : IAsn1Set; overload; static;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      explicitly: Boolean): IAsn1Set; overload; static;
 
     property Parser: IAsn1SetParser read GetParser;
     property Count: Int32 read GetCount;
@@ -162,7 +162,7 @@ uses
 
 { TAsn1Set }
 
-procedure TAsn1Set.AddObject(obj: IAsn1Encodable);
+procedure TAsn1Set.AddObject(const obj: IAsn1Encodable);
 begin
   F_set.Add(obj);
 end;
@@ -183,7 +183,7 @@ begin
   result := encObj;
 end;
 
-function TAsn1Set.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TAsn1Set.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IAsn1Set;
   s1, s2: TEnumerator<IAsn1Encodable>;
@@ -205,19 +205,24 @@ begin
   s1 := GetEnumerator;
   s2 := other.GetEnumerator;
 
-  while (s1.MoveNext() and s2.MoveNext()) do
-  begin
-    o1 := GetCurrent(s1).ToAsn1Object();
-    o2 := GetCurrent(s2).ToAsn1Object();
-
-    if (not(o1.Equals(o2))) then
+  try
+    while (s1.MoveNext() and s2.MoveNext()) do
     begin
-      result := false;
-      Exit;
+      o1 := GetCurrent(s1).ToAsn1Object();
+      o2 := GetCurrent(s2).ToAsn1Object();
+
+      if (not(o1.Equals(o2))) then
+      begin
+        result := false;
+        Exit;
+      end;
     end;
-  end;
 
-  result := true;
+    result := true;
+  finally
+    s1.Free;
+    s2.Free;
+  end;
 end;
 
 function TAsn1Set.Asn1GetHashCode: Int32;
@@ -280,8 +285,8 @@ begin
   end;
 end;
 
-class function TAsn1Set.GetInstance(obj: IAsn1TaggedObject; explicitly: Boolean)
-  : IAsn1Set;
+class function TAsn1Set.GetInstance(const obj: IAsn1TaggedObject;
+  explicitly: Boolean): IAsn1Set;
 var
   inner: IAsn1Object;
   asn1Set: IAsn1Set;
@@ -481,7 +486,7 @@ end;
 
 { TAsn1Set.TAsn1SetParserImpl }
 
-constructor TAsn1Set.TAsn1SetParserImpl.Create(outer: IAsn1Set);
+constructor TAsn1Set.TAsn1SetParserImpl.Create(const outer: IAsn1Set);
 begin
   Inherited Create();
   Fouter := outer;

CryptoLib/src/Asn1/ClpAsn1StreamParser.pas

@@ -327,7 +327,7 @@ begin
   if ((tag and TAsn1Tags.Tagged) <> 0) then
   begin
     result := TBerTaggedObjectParser.Create(isConstructed, tagNo,
-      TAsn1StreamParser.Create(defIn));
+      TAsn1StreamParser.Create(defIn) as IAsn1StreamParser);
     Exit;
 
   end;
@@ -343,22 +343,24 @@ begin
           // yes, people actually do this...
           //
 
-          result := TBerOctetStringParser.Create
-            (TAsn1StreamParser.Create(defIn));
+          result := TBerOctetStringParser.Create(TAsn1StreamParser.Create(defIn)
+            as IAsn1StreamParser);
           Exit;
 
         end;
       TAsn1Tags.Sequence:
         begin
 
-          result := TDerSequenceParser.Create(TAsn1StreamParser.Create(defIn));
+          result := TDerSequenceParser.Create(TAsn1StreamParser.Create(defIn)
+            as IAsn1StreamParser);
           Exit;
 
         end;
       TAsn1Tags.&Set:
         begin
 
-          result := TDerSetParser.Create(TAsn1StreamParser.Create(defIn));
+          result := TDerSetParser.Create(TAsn1StreamParser.Create(defIn)
+            as IAsn1StreamParser);
           Exit;
 
         end;
@@ -366,7 +368,8 @@ begin
       TAsn1Tags.External:
         begin
 
-          result := TDerExternalParser.Create(TAsn1StreamParser.Create(defIn));
+          result := TDerExternalParser.Create(TAsn1StreamParser.Create(defIn)
+            as IAsn1StreamParser);
           Exit;
 
         end;

CryptoLib/src/Asn1/ClpAsn1TaggedObject.pas

@@ -63,24 +63,24 @@ type
     // * @param tagNo the tag number for this object.
     // * @param obj the tagged object.
     // */
-    constructor Create(tagNo: Int32; obj: IAsn1Encodable); overload;
+    constructor Create(tagNo: Int32; const obj: IAsn1Encodable); overload;
     // /**
     // * @param explicitly true if the object is explicitly tagged.
     // * @param tagNo the tag number for this object.
     // * @param obj the tagged object.
     // */
     constructor Create(explicitly: Boolean; tagNo: Int32;
-      obj: IAsn1Encodable); overload;
+      const obj: IAsn1Encodable); overload;
 
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
     function Asn1GetHashCode(): Int32; override;
 
   public
-    class function IsConstructed(isExplicit: Boolean; obj: IAsn1Object)
+    class function IsConstructed(isExplicit: Boolean; const obj: IAsn1Object)
       : Boolean; static;
-    class function GetInstance(obj: IAsn1TaggedObject; explicitly: Boolean)
-      : IAsn1TaggedObject; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      explicitly: Boolean): IAsn1TaggedObject; overload; static; inline;
     class function GetInstance(obj: TObject): IAsn1TaggedObject; overload;
       static; inline;
 
@@ -140,7 +140,7 @@ begin
   result := Nil;
 end;
 
-function TAsn1TaggedObject.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TAsn1TaggedObject.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IAsn1TaggedObject;
 begin
@@ -178,7 +178,7 @@ begin
   result := code;
 end;
 
-constructor TAsn1TaggedObject.Create(tagNo: Int32; obj: IAsn1Encodable);
+constructor TAsn1TaggedObject.Create(tagNo: Int32; const obj: IAsn1Encodable);
 begin
   Inherited Create();
   Fexplicitly := true;
@@ -187,7 +187,7 @@ begin
 end;
 
 constructor TAsn1TaggedObject.Create(explicitly: Boolean; tagNo: Int32;
-  obj: IAsn1Encodable);
+  const obj: IAsn1Encodable);
 begin
   Inherited Create();
   // IAsn1Choice marker interface 'insists' on explicit tagging
@@ -218,7 +218,7 @@ begin
   result := Fobj;
 end;
 
-class function TAsn1TaggedObject.GetInstance(obj: IAsn1TaggedObject;
+class function TAsn1TaggedObject.GetInstance(const obj: IAsn1TaggedObject;
   explicitly: Boolean): IAsn1TaggedObject;
 begin
   if (explicitly) then
@@ -271,7 +271,7 @@ begin
 end;
 
 class function TAsn1TaggedObject.IsConstructed(isExplicit: Boolean;
-  obj: IAsn1Object): Boolean;
+  const obj: IAsn1Object): Boolean;
 var
   tagged: IAsn1TaggedObject;
 begin

CryptoLib/src/Asn1/ClpBerApplicationSpecific.pas

@@ -31,7 +31,7 @@ type
     IBerApplicationSpecific)
 
   public
-    constructor Create(tagNo: Int32; vec: IAsn1EncodableVector);
+    constructor Create(tagNo: Int32; const vec: IAsn1EncodableVector);
 
   end;
 
@@ -40,7 +40,7 @@ implementation
 { TBerApplicationSpecific }
 
 constructor TBerApplicationSpecific.Create(tagNo: Int32;
-  vec: IAsn1EncodableVector);
+  const vec: IAsn1EncodableVector);
 begin
   inherited Create(tagNo, vec);
 end;

CryptoLib/src/Asn1/ClpBerApplicationSpecificParser.pas

@@ -40,7 +40,7 @@ type
 
   public
 
-    constructor Create(tag: Int32; parser: IAsn1StreamParser);
+    constructor Create(tag: Int32; const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; inline;
 
@@ -51,7 +51,7 @@ implementation
 { TBerApplicationSpecificParser }
 
 constructor TBerApplicationSpecificParser.Create(tag: Int32;
-  parser: IAsn1StreamParser);
+  const parser: IAsn1StreamParser);
 begin
   F_tag := tag;
   F_parser := parser;

CryptoLib/src/Asn1/ClpBerBitString.pas

@@ -38,9 +38,9 @@ type
     constructor Create(data: TCryptoLibByteArray; padBits: Int32); overload;
     constructor Create(data: TCryptoLibByteArray); overload;
     constructor Create(namedBits: Int32); overload;
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
   end;
 
@@ -58,7 +58,7 @@ begin
   Inherited Create(data, padBits);
 end;
 
-constructor TBerBitString.Create(obj: IAsn1Encodable);
+constructor TBerBitString.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(obj);
 end;
@@ -68,7 +68,7 @@ begin
   Inherited Create(namedBits);
 end;
 
-procedure TBerBitString.Encode(derOut: IDerOutputStream);
+procedure TBerBitString.Encode(const derOut: IDerOutputStream);
 begin
   if ((Supports(derOut, IAsn1OutputStream)) or
     (Supports(derOut, IBerOutputStream))) then

CryptoLib/src/Asn1/ClpBerGenerator.pas

@@ -52,7 +52,7 @@ type
     procedure WriteBerEnd();
 
   public
-    procedure AddObject(obj: IAsn1Encodable); override;
+    procedure AddObject(const obj: IAsn1Encodable); override;
     function GetRawOutputStream(): TStream; override;
     procedure Close(); override;
 
@@ -67,7 +67,7 @@ begin
   Inherited Create(outStream);
 end;
 
-procedure TBerGenerator.AddObject(obj: IAsn1Encodable);
+procedure TBerGenerator.AddObject(const obj: IAsn1Encodable);
 var
   temp: TBerOutputStream;
 begin

CryptoLib/src/Asn1/ClpBerNull.pas

@@ -51,7 +51,7 @@ type
 
   public
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
     class property Instance: IBerNull read GetInstance;
 
   end;
@@ -70,7 +70,7 @@ begin
   FInstance := TBerNull.Create(0);
 end;
 
-procedure TBerNull.Encode(derOut: IDerOutputStream);
+procedure TBerNull.Encode(const derOut: IDerOutputStream);
 begin
 
   if (Supports(derOut, IAsn1OutputStream) or Supports(derOut, IBerOutputStream))

CryptoLib/src/Asn1/ClpBerOctetString.pas

@@ -57,8 +57,8 @@ type
     /// <param name="str">The octets making up the octet string.</param>
     constructor Create(str: TCryptoLibByteArray); overload;
     constructor Create(octets: TEnumerable<IDerOctetString>); overload;
-    constructor Create(obj: IAsn1Object); overload;
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Object); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     destructor Destroy(); override;
 
@@ -69,9 +69,10 @@ type
     /// </summary>
     function GetEnumerator: TEnumerator<IDerOctetString>;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
-    class function FromSequence(seq: IAsn1Sequence): IBerOctetString; static;
+    class function FromSequence(const seq: IAsn1Sequence)
+      : IBerOctetString; static;
 
   end;
 
@@ -90,7 +91,7 @@ begin
   Inherited Create(str);
 end;
 
-constructor TBerOctetString.Create(obj: IAsn1Encodable);
+constructor TBerOctetString.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(obj.ToAsn1Object());
 end;
@@ -101,12 +102,12 @@ begin
   inherited Destroy;
 end;
 
-constructor TBerOctetString.Create(obj: IAsn1Object);
+constructor TBerOctetString.Create(const obj: IAsn1Object);
 begin
   Inherited Create(obj);
 end;
 
-procedure TBerOctetString.Encode(derOut: IDerOutputStream);
+procedure TBerOctetString.Encode(const derOut: IDerOutputStream);
 var
   oct: IDerOctetString;
 begin
@@ -134,7 +135,7 @@ begin
   end;
 end;
 
-class function TBerOctetString.FromSequence(seq: IAsn1Sequence)
+class function TBerOctetString.FromSequence(const seq: IAsn1Sequence)
   : IBerOctetString;
 var
   v: TList<IDerOctetString>;
@@ -166,7 +167,7 @@ begin
     System.SetLength(nStr, endPoint - i);
 
     System.Move(str[i], nStr[0], System.Length(nStr) * System.SizeOf(Byte));
-    result.Add(TDerOctetString.Create(nStr));
+    result.Add(TDerOctetString.Create(nStr) as IDerOctetString);
     System.Inc(i, MaxLength);
   end;
   Focts := result; // review removal

CryptoLib/src/Asn1/ClpBerOctetStringParser.pas

@@ -45,7 +45,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function GetOctetStream(): TStream; inline;
     function ToAsn1Object(): IAsn1Object;
 
@@ -55,8 +55,9 @@ implementation
 
 { TBerOctetStringParser }
 
-constructor TBerOctetStringParser.Create(parser: IAsn1StreamParser);
+constructor TBerOctetStringParser.Create(const parser: IAsn1StreamParser);
 begin
+  Inherited Create();
   F_parser := parser;
 end;
 

CryptoLib/src/Asn1/ClpBerSequence.pas

@@ -46,7 +46,8 @@ type
 
   public
 
-    class function FromVector(v: IAsn1EncodableVector): IBerSequence; static;
+    class function FromVector(const v: IAsn1EncodableVector)
+      : IBerSequence; static;
 
     /// <summary>
     /// create an empty sequence
@@ -56,14 +57,14 @@ type
     /// <summary>
     /// create a sequence containing one object
     /// </summary>
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     constructor Create(v: array of IAsn1Encodable); overload;
 
     /// <summary>
     /// create a sequence containing a vector of objects.
     /// </summary>
-    constructor Create(v: IAsn1EncodableVector); overload;
+    constructor Create(const v: IAsn1EncodableVector); overload;
 
     destructor Destroy(); override;
 
@@ -74,7 +75,7 @@ type
     /// just outputing Sequence, <br />we also have to specify Constructed,
     /// and the objects length. <br />
     /// </summary>
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     class property Empty: IBerSequence read GetEmpty;
 
@@ -84,7 +85,7 @@ implementation
 
 { TBerSequence }
 
-constructor TBerSequence.Create(obj: IAsn1Encodable);
+constructor TBerSequence.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(obj);
 end;
@@ -94,7 +95,7 @@ begin
   Inherited Create();
 end;
 
-constructor TBerSequence.Create(v: IAsn1EncodableVector);
+constructor TBerSequence.Create(const v: IAsn1EncodableVector);
 begin
   Inherited Create(v);
 end;
@@ -115,7 +116,7 @@ begin
   FEmpty := TBerSequence.Create();
 end;
 
-procedure TBerSequence.Encode(derOut: IDerOutputStream);
+procedure TBerSequence.Encode(const derOut: IDerOutputStream);
 var
   o: IAsn1Encodable;
 begin
@@ -141,7 +142,8 @@ begin
 
 end;
 
-class function TBerSequence.FromVector(v: IAsn1EncodableVector): IBerSequence;
+class function TBerSequence.FromVector(const v: IAsn1EncodableVector)
+  : IBerSequence;
 begin
   if v.Count < 1 then
   begin

CryptoLib/src/Asn1/ClpBerSequenceParser.pas

@@ -38,7 +38,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; inline;
 
@@ -48,7 +48,7 @@ implementation
 
 { TBerSequenceParser }
 
-constructor TBerSequenceParser.Create(parser: IAsn1StreamParser);
+constructor TBerSequenceParser.Create(const parser: IAsn1StreamParser);
 begin
   F_parser := parser;
 end;

CryptoLib/src/Asn1/ClpBerSet.pas

@@ -48,10 +48,10 @@ type
 
   public
 
-    class function FromVector(v: IAsn1EncodableVector): IBerSet;
+    class function FromVector(const v: IAsn1EncodableVector): IBerSet;
       overload; static;
-    class function FromVector(v: IAsn1EncodableVector; needsSorting: Boolean)
-      : IBerSet; overload; static;
+    class function FromVector(const v: IAsn1EncodableVector;
+      needsSorting: Boolean): IBerSet; overload; static;
 
     /// <summary>
     /// create an empty set
@@ -61,15 +61,15 @@ type
     /// <param name="obj">
     /// a single object that makes up the set.
     /// </param>
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     /// <param name="v">
     /// a vector of objects making up the set.
     /// </param>
-    constructor Create(v: IAsn1EncodableVector); overload;
+    constructor Create(const v: IAsn1EncodableVector); overload;
 
-    constructor Create(v: IAsn1EncodableVector; needsSorting: Boolean);
-      overload;
+    constructor Create(const v: IAsn1EncodableVector;
+      needsSorting: Boolean); overload;
 
     destructor Destroy(); override;
 
@@ -80,7 +80,7 @@ type
     /// just outputing Set, <br />we also have to specify Constructed, and
     /// the objects length. <br />
     /// </summary>
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     class property Empty: IBerSet read GetEmpty;
 
@@ -95,7 +95,8 @@ begin
   Inherited Create();
 end;
 
-constructor TBerSet.Create(v: IAsn1EncodableVector; needsSorting: Boolean);
+constructor TBerSet.Create(const v: IAsn1EncodableVector;
+  needsSorting: Boolean);
 begin
   Inherited Create(v, needsSorting);
 end;
@@ -106,12 +107,12 @@ begin
   inherited Destroy;
 end;
 
-constructor TBerSet.Create(obj: IAsn1Encodable);
+constructor TBerSet.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(obj);
 end;
 
-constructor TBerSet.Create(v: IAsn1EncodableVector);
+constructor TBerSet.Create(const v: IAsn1EncodableVector);
 begin
   Inherited Create(v, false);
 end;
@@ -121,7 +122,7 @@ begin
   FEmpty := TBerSet.Create();
 end;
 
-procedure TBerSet.Encode(derOut: IDerOutputStream);
+procedure TBerSet.Encode(const derOut: IDerOutputStream);
 var
   o: IAsn1Encodable;
 begin
@@ -146,7 +147,7 @@ begin
   end;
 end;
 
-class function TBerSet.FromVector(v: IAsn1EncodableVector;
+class function TBerSet.FromVector(const v: IAsn1EncodableVector;
   needsSorting: Boolean): IBerSet;
 begin
   if v.Count < 1 then
@@ -164,7 +165,7 @@ begin
   result := FEmpty;
 end;
 
-class function TBerSet.FromVector(v: IAsn1EncodableVector): IBerSet;
+class function TBerSet.FromVector(const v: IAsn1EncodableVector): IBerSet;
 begin
   if v.Count < 1 then
   begin

CryptoLib/src/Asn1/ClpBerSetParser.pas

@@ -38,7 +38,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; inline;
 
@@ -48,7 +48,7 @@ implementation
 
 { TBerSetParser }
 
-constructor TBerSetParser.Create(parser: IAsn1StreamParser);
+constructor TBerSetParser.Create(const parser: IAsn1StreamParser);
 begin
   F_parser := parser;
 end;

CryptoLib/src/Asn1/ClpBerTaggedObject.pas

@@ -60,7 +60,7 @@ type
     /// <param name="obj">
     /// the tagged object.
     /// </param>
-    constructor Create(tagNo: Int32; obj: IAsn1Encodable); overload;
+    constructor Create(tagNo: Int32; const obj: IAsn1Encodable); overload;
     /// <param name="explicitly">
     /// true if an explicitly tagged object.
     /// </param>
@@ -71,7 +71,7 @@ type
     /// the tagged object.
     /// </param>
     constructor Create(explicitly: Boolean; tagNo: Int32;
-      obj: IAsn1Encodable); overload;
+      const obj: IAsn1Encodable); overload;
 
     /// <summary>
     /// create an implicitly tagged object that contains a zero length
@@ -82,7 +82,7 @@ type
     /// </param>
     constructor Create(tagNo: Int32); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
   end;
 
@@ -90,13 +90,13 @@ implementation
 
 { TBerTaggedObject }
 
-constructor TBerTaggedObject.Create(tagNo: Int32; obj: IAsn1Encodable);
+constructor TBerTaggedObject.Create(tagNo: Int32; const obj: IAsn1Encodable);
 begin
   Inherited Create(tagNo, obj);
 end;
 
 constructor TBerTaggedObject.Create(explicitly: Boolean; tagNo: Int32;
-  obj: IAsn1Encodable);
+  const obj: IAsn1Encodable);
 begin
   Inherited Create(explicitly, tagNo, obj)
 end;
@@ -106,7 +106,7 @@ begin
   Inherited Create(false, tagNo, TBerSequence.Empty)
 end;
 
-procedure TBerTaggedObject.Encode(derOut: IDerOutputStream);
+procedure TBerTaggedObject.Encode(const derOut: IDerOutputStream);
 var
   eObj: TList<IAsn1Encodable>;
   enumeratorIBerOctetString: TEnumerator<IDerOctetString>;
@@ -129,17 +129,18 @@ begin
       begin
         if (not explicitly) then
         begin
-
-          // asn1OctetString := obj as IAsn1OctetString;
           if (Supports(obj, IAsn1OctetString, asn1OctetString)) then
           begin
-            // berOctetString := asn1OctetString as IBerOctetString;
             if (Supports(asn1OctetString, IBerOctetString, berOctetString)) then
             begin
               enumeratorIBerOctetString := berOctetString.GetEnumerator;
-              while enumeratorIBerOctetString.MoveNext do
-              begin
-                eObj.Add(enumeratorIBerOctetString.Current as IAsn1Encodable);
+              try
+                while enumeratorIBerOctetString.MoveNext do
+                begin
+                  eObj.Add(enumeratorIBerOctetString.Current as IAsn1Encodable);
+                end;
+              finally
+                enumeratorIBerOctetString.Free;
               end;
             end
             else
@@ -147,30 +148,38 @@ begin
               enumeratorIBerOctetString :=
                 TBerOctetString.Create(asn1OctetString.GetOctets())
                 .GetEnumerator;
-              while enumeratorIBerOctetString.MoveNext do
-              begin
-                eObj.Add(enumeratorIBerOctetString.Current as IAsn1Encodable);
+              try
+                while enumeratorIBerOctetString.MoveNext do
+                begin
+                  eObj.Add(enumeratorIBerOctetString.Current as IAsn1Encodable);
+                end;
+              finally
+                enumeratorIBerOctetString.Free;
               end;
             end
           end
           else if Supports(obj, IAsn1Sequence, asn1Sequence) then
           begin
-            // eObj := obj as IAsn1Sequence;
-            // asn1Sequence := obj as IAsn1Sequence;
             enumeratorIAsn1Sequence := asn1Sequence.GetEnumerator;
-            while enumeratorIAsn1Sequence.MoveNext do
-            begin
-              eObj.Add(enumeratorIAsn1Sequence.Current);
+            try
+              while enumeratorIAsn1Sequence.MoveNext do
+              begin
+                eObj.Add(enumeratorIAsn1Sequence.Current);
+              end;
+            finally
+              enumeratorIAsn1Sequence.Free;
             end;
           end
           else if Supports(obj, IAsn1Set, asn1Set) then
           begin
-            // eObj := obj as IAsn1Set;
-            // asn1Set := obj as IAsn1Set;
             enumeratorIAsn1Set := asn1Set.GetEnumerator;
-            while enumeratorIAsn1Set.MoveNext do
-            begin
-              eObj.Add(enumeratorIAsn1Set.Current);
+            try
+              while enumeratorIAsn1Set.MoveNext do
+              begin
+                eObj.Add(enumeratorIAsn1Set.Current);
+              end;
+            finally
+              enumeratorIAsn1Set.Free;
             end;
           end
           else

CryptoLib/src/Asn1/ClpBerTaggedObjectParser.pas

@@ -47,7 +47,7 @@ type
 
   public
     constructor Create(constructed: Boolean; tagNumber: Int32;
-      parser: IAsn1StreamParser);
+      const parser: IAsn1StreamParser);
 
     function GetObjectParser(tag: Int32; isExplicit: Boolean)
       : IAsn1Convertible; inline;
@@ -64,7 +64,7 @@ implementation
 { TBerTaggedObjectParser }
 
 constructor TBerTaggedObjectParser.Create(constructed: Boolean;
-  tagNumber: Int32; parser: IAsn1StreamParser);
+  tagNumber: Int32; const parser: IAsn1StreamParser);
 begin
   F_constructed := constructed;
   F_tagNumber := tagNumber;

CryptoLib/src/Asn1/ClpConstructedOctetStream.pas

@@ -40,7 +40,7 @@ type
     F_currentStream: TStream;
 
   public
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function Read(buffer: TCryptoLibByteArray; offset, count: Int32)
       : Int32; override;
     function ReadByte(): Int32; override;
@@ -53,7 +53,7 @@ uses
 
 { TConstructedOctetStream }
 
-constructor TConstructedOctetStream.Create(parser: IAsn1StreamParser);
+constructor TConstructedOctetStream.Create(const parser: IAsn1StreamParser);
 begin
   Inherited Create();
   F_parser := parser;

CryptoLib/src/Asn1/ClpDerApplicationSpecific.pas

@@ -59,17 +59,17 @@ type
       : TCryptoLibByteArray; static;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
     function Asn1GetHashCode(): Int32; override;
 
   public
     constructor Create(isConstructed: Boolean; tag: Int32;
       octets: TCryptoLibByteArray); overload;
     constructor Create(tag: Int32; octets: TCryptoLibByteArray); overload;
-    constructor Create(tag: Int32; obj: IAsn1Encodable); overload;
+    constructor Create(tag: Int32; const obj: IAsn1Encodable); overload;
     constructor Create(isExplicit: Boolean; tag: Int32;
-      obj: IAsn1Encodable); overload;
-    constructor Create(tagNo: Int32; vec: IAsn1EncodableVector); overload;
+      const obj: IAsn1Encodable); overload;
+    constructor Create(tagNo: Int32; const vec: IAsn1EncodableVector); overload;
 
     function isConstructed(): Boolean; inline;
     function GetContents(): TCryptoLibByteArray; inline;
@@ -99,7 +99,7 @@ type
     /// </exception>
     function GetObject(derTagNo: Int32): IAsn1Object; overload; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     property ApplicationTag: Int32 read GetApplicationTag;
   end;
@@ -139,7 +139,8 @@ begin
   result := 2;
 end;
 
-constructor TDerApplicationSpecific.Create(tag: Int32; obj: IAsn1Encodable);
+constructor TDerApplicationSpecific.Create(tag: Int32;
+  const obj: IAsn1Encodable);
 begin
   Create(true, tag, obj);
 end;
@@ -159,7 +160,8 @@ begin
   Foctets := octets;
 end;
 
-function TDerApplicationSpecific.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerApplicationSpecific.Asn1Equals(const asn1Object
+  : IAsn1Object): Boolean;
 var
   other: IDerApplicationSpecific;
 begin
@@ -191,7 +193,7 @@ begin
 end;
 
 constructor TDerApplicationSpecific.Create(tagNo: Int32;
-  vec: IAsn1EncodableVector);
+  const vec: IAsn1EncodableVector);
 var
   bOut: TMemoryStream;
   bs: TCryptoLibByteArray;
@@ -232,7 +234,7 @@ begin
 
 end;
 
-procedure TDerApplicationSpecific.Encode(derOut: IDerOutputStream);
+procedure TDerApplicationSpecific.Encode(const derOut: IDerOutputStream);
 var
   classBits: Int32;
 begin
@@ -246,7 +248,7 @@ begin
 end;
 
 constructor TDerApplicationSpecific.Create(isExplicit: Boolean; tag: Int32;
-  obj: IAsn1Encodable);
+  const obj: IAsn1Encodable);
 var
   asn1Obj: IAsn1Object;
   data, tmp: TCryptoLibByteArray;

CryptoLib/src/Asn1/ClpDerBitString.pas

@@ -70,7 +70,7 @@ type
     property mPadBits: Int32 read GetmPadBits;
 
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     constructor Create(data: TCryptoLibByteArray; padBits: Int32); overload;
@@ -79,7 +79,7 @@ type
 
     constructor Create(namedBits: Int32); overload;
 
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     function GetString(): String; override;
 
@@ -87,7 +87,7 @@ type
 
     function GetBytes(): TCryptoLibByteArray; virtual;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     function GetInt32Value: Int32; virtual;
     property Int32Value: Int32 read GetInt32Value;
@@ -122,8 +122,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerBitString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerBitString; overload; static; inline;
 
     class function FromAsn1Octets(octets: TCryptoLibByteArray)
       : IDerBitString; static;
@@ -162,7 +162,7 @@ begin
   result := System.Copy(mData);
 end;
 
-function TDerBitString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerBitString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerBitString;
 begin
@@ -251,7 +251,7 @@ begin
   FmPadBits := padBits;
 end;
 
-procedure TDerBitString.Encode(derOut: IDerOutputStream);
+procedure TDerBitString.Encode(const derOut: IDerOutputStream);
 var
   last, mask, unusedBits: Int32;
   contents: TCryptoLibByteArray;
@@ -321,7 +321,7 @@ begin
 
 end;
 
-class function TDerBitString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerBitString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerBitString;
 var
   o: IAsn1Object;
@@ -409,7 +409,7 @@ begin
   result := mPadBits xor TArrayUtils.GetArrayHashCode(mData);
 end;
 
-constructor TDerBitString.Create(obj: IAsn1Encodable);
+constructor TDerBitString.Create(const obj: IAsn1Encodable);
 begin
   Create(obj.GetDerEncoded());
 end;

CryptoLib/src/Asn1/ClpDerBmpString.pas

@@ -46,7 +46,7 @@ type
     function GetStr: String; inline;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
     property Str: String read GetStr;
@@ -63,7 +63,7 @@ type
 
     function GetString(): String; override;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a BMP string from the given object.
@@ -89,8 +89,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerBmpString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerBmpString; overload; static; inline;
 
   end;
 
@@ -98,7 +98,7 @@ implementation
 
 { TDerBmpString }
 
-function TDerBmpString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerBmpString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerBmpString;
 begin
@@ -147,7 +147,7 @@ begin
   FStr := astr;
 end;
 
-procedure TDerBmpString.Encode(derOut: IDerOutputStream);
+procedure TDerBmpString.Encode(const derOut: IDerOutputStream);
 var
   c: TCryptoLibCharArray;
   b: TCryptoLibByteArray;
@@ -181,7 +181,7 @@ begin
     [obj.ClassName]);
 end;
 
-class function TDerBmpString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerBmpString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerBmpString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerBoolean.pas

@@ -58,14 +58,14 @@ type
     class constructor DerBoolean();
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
     function Asn1GetHashCode(): Int32; override;
 
   public
 
     constructor Create(val: TCryptoLibByteArray); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     function ToString(): String; override;
 
@@ -103,8 +103,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerBoolean; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerBoolean; overload; static; inline;
 
     class function FromOctetString(value: TCryptoLibByteArray)
       : IDerBoolean; static;
@@ -115,7 +115,7 @@ implementation
 
 { TDerBoolean }
 
-function TDerBoolean.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerBoolean.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerBoolean;
 begin
@@ -165,7 +165,7 @@ begin
   FTrue := TDerBoolean.Create(System.True);
 end;
 
-procedure TDerBoolean.Encode(derOut: IDerOutputStream);
+procedure TDerBoolean.Encode(const derOut: IDerOutputStream);
 begin
   // TODO Should we make sure the byte value is one of '0' or '0xff' here?
   derOut.WriteEncoded(TAsn1Tags.Boolean, TCryptoLibByteArray.Create(Fvalue));
@@ -227,7 +227,7 @@ begin
   result := FFalse;
 end;
 
-class function TDerBoolean.GetInstance(obj: IAsn1TaggedObject;
+class function TDerBoolean.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerBoolean;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerEnumerated.pas

@@ -56,16 +56,16 @@ type
 
   strict protected
 
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
     function Asn1GetHashCode(): Int32; override;
 
   public
 
     constructor Create(val: Int32); overload;
-    constructor Create(val: TBigInteger); overload;
+    constructor Create(const val: TBigInteger); overload;
     constructor Create(bytes: TCryptoLibByteArray); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     property Value: TBigInteger read GetValue;
     property bytes: TCryptoLibByteArray read GetBytes;
@@ -92,8 +92,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerEnumerated; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerEnumerated; overload; static; inline;
 
     class function FromOctetString(enc: TCryptoLibByteArray)
       : IDerEnumerated; static;
@@ -104,7 +104,7 @@ implementation
 
 { TDerEnumerated }
 
-function TDerEnumerated.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerEnumerated.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerEnumerated;
 begin
@@ -129,7 +129,7 @@ begin
   Fbytes := TBigInteger.ValueOf(val).ToByteArray();
 end;
 
-constructor TDerEnumerated.Create(val: TBigInteger);
+constructor TDerEnumerated.Create(const val: TBigInteger);
 begin
   Inherited Create();
   Fbytes := val.ToByteArray();
@@ -157,7 +157,7 @@ begin
   System.SetLength(Fcache, 12);
 end;
 
-procedure TDerEnumerated.Encode(derOut: IDerOutputStream);
+procedure TDerEnumerated.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.Enumerated, Fbytes);
 end;
@@ -210,7 +210,7 @@ begin
     [obj.ClassName]);
 end;
 
-class function TDerEnumerated.GetInstance(obj: IAsn1TaggedObject;
+class function TDerEnumerated.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerEnumerated;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerExternal.pas

@@ -82,17 +82,17 @@ type
     procedure SetExternalContent(const Value: IAsn1Object);
     procedure SetIndirectReference(const Value: IDerInteger);
 
-    class function GetObjFromVector(v: IAsn1EncodableVector; index: Int32)
+    class function GetObjFromVector(const v: IAsn1EncodableVector; index: Int32)
       : IAsn1Object; static; inline;
-    class procedure WriteEncodable(ms: TMemoryStream; e: IAsn1Encodable);
+    class procedure WriteEncodable(ms: TMemoryStream; const e: IAsn1Encodable);
       static; inline;
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
-    constructor Create(vector: IAsn1EncodableVector); overload;
+    constructor Create(const vector: IAsn1EncodableVector); overload;
 
     /// <summary>
     /// Creates a new instance of DerExternal <br />See X.690 for more
@@ -111,15 +111,17 @@ type
     /// <param name="externalData">
     /// The external data in its encoded form.
     /// </param>
-    constructor Create(directReference: IDerObjectIdentifier;
-      indirectReference: IDerInteger; dataValueDescriptor: IAsn1Object;
-      externalData: IDerTaggedObject); overload;
+    constructor Create(const directReference: IDerObjectIdentifier;
+      const indirectReference: IDerInteger;
+      const dataValueDescriptor: IAsn1Object;
+      const externalData: IDerTaggedObject); overload;
 
-    constructor Create(directReference: IDerObjectIdentifier;
-      indirectReference: IDerInteger; dataValueDescriptor: IAsn1Object;
-      encoding: Int32; externalData: IAsn1Object); overload;
+    constructor Create(const directReference: IDerObjectIdentifier;
+      const indirectReference: IDerInteger;
+      const dataValueDescriptor: IAsn1Object; encoding: Int32;
+      const externalData: IAsn1Object); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     property dataValueDescriptor: IAsn1Object read GetDataValueDescriptor
       write SetDataValueDescriptor;
@@ -141,7 +143,7 @@ implementation
 
 { TDerExternal }
 
-class function TDerExternal.GetObjFromVector(v: IAsn1EncodableVector;
+class function TDerExternal.GetObjFromVector(const v: IAsn1EncodableVector;
   index: Int32): IAsn1Object;
 var
   val: IAsn1Encodable;
@@ -156,7 +158,7 @@ begin
 end;
 
 class procedure TDerExternal.WriteEncodable(ms: TMemoryStream;
-  e: IAsn1Encodable);
+  const e: IAsn1Encodable);
 var
   bs: TCryptoLibByteArray;
 begin
@@ -167,7 +169,7 @@ begin
   end;
 end;
 
-function TDerExternal.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerExternal.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerExternal;
 begin
@@ -209,9 +211,9 @@ begin
   result := ret;
 end;
 
-constructor TDerExternal.Create(directReference: IDerObjectIdentifier;
-  indirectReference: IDerInteger; dataValueDescriptor: IAsn1Object;
-  encoding: Int32; externalData: IAsn1Object);
+constructor TDerExternal.Create(const directReference: IDerObjectIdentifier;
+  const indirectReference: IDerInteger; const dataValueDescriptor: IAsn1Object;
+  encoding: Int32; const externalData: IAsn1Object);
 begin
   Inherited Create();
   FdirectReference := directReference;
@@ -221,7 +223,7 @@ begin
   FexternalContent := externalData.ToAsn1Object();
 end;
 
-constructor TDerExternal.Create(vector: IAsn1EncodableVector);
+constructor TDerExternal.Create(const vector: IAsn1EncodableVector);
 var
   offset: Int32;
   enc: IAsn1Object;
@@ -274,15 +276,15 @@ begin
   FexternalContent := obj.GetObject();
 end;
 
-constructor TDerExternal.Create(directReference: IDerObjectIdentifier;
-  indirectReference: IDerInteger; dataValueDescriptor: IAsn1Object;
-  externalData: IDerTaggedObject);
+constructor TDerExternal.Create(const directReference: IDerObjectIdentifier;
+  const indirectReference: IDerInteger; const dataValueDescriptor: IAsn1Object;
+  const externalData: IDerTaggedObject);
 begin
   Create(directReference, indirectReference, dataValueDescriptor,
     externalData.TagNo, externalData.ToAsn1Object());
 end;
 
-procedure TDerExternal.Encode(derOut: IDerOutputStream);
+procedure TDerExternal.Encode(const derOut: IDerOutputStream);
 var
   ms: TMemoryStream;
   Buffer: TCryptoLibByteArray;

CryptoLib/src/Asn1/ClpDerExternalParser.pas

@@ -37,7 +37,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; override;
 
@@ -47,7 +47,7 @@ implementation
 
 { TDerExternalParser }
 
-constructor TDerExternalParser.Create(parser: IAsn1StreamParser);
+constructor TDerExternalParser.Create(const parser: IAsn1StreamParser);
 begin
   Inherited Create();
   F_parser := parser;

CryptoLib/src/Asn1/ClpDerGeneralString.pas

@@ -49,7 +49,7 @@ type
     property Str: String read GetStr;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     constructor Create(Str: TCryptoLibByteArray); overload;
@@ -60,13 +60,13 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     class function GetInstance(obj: TObject): IDerGeneralString; overload;
       static; inline;
 
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerGeneralString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerGeneralString; overload; static; inline;
 
   end;
 
@@ -83,7 +83,7 @@ begin
 {$ENDIF FPC}
 end;
 
-function TDerGeneralString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerGeneralString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerGeneralString;
 begin
@@ -117,12 +117,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerGeneralString.Encode(derOut: IDerOutputStream);
+procedure TDerGeneralString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.GeneralString, GetOctets());
 end;
 
-class function TDerGeneralString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerGeneralString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerGeneralString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerGraphicString.pas

@@ -48,7 +48,7 @@ type
 
   protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
     property mString: TCryptoLibByteArray read GetmString;
@@ -65,7 +65,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a Graphic String from the passed in object
@@ -97,8 +97,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerGraphicString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerGraphicString; overload; static; inline;
 
   end;
 
@@ -106,7 +106,7 @@ implementation
 
 { TDerGraphicString }
 
-function TDerGraphicString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerGraphicString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerGraphicString;
 begin
@@ -131,7 +131,7 @@ begin
   FmString := System.Copy(encoding);
 end;
 
-procedure TDerGraphicString.Encode(derOut: IDerOutputStream);
+procedure TDerGraphicString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.GraphicString, mString);
 end;
@@ -148,7 +148,7 @@ begin
     [obj.ClassName]);
 end;
 
-class function TDerGraphicString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerGraphicString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerGraphicString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerIA5String.pas

@@ -54,7 +54,7 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -86,7 +86,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a DerIA5String from the passed in object
@@ -115,8 +115,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerIA5String; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerIA5String; overload; static; inline;
 
     /// <summary>
     /// return true if the passed in String can be represented without loss
@@ -158,7 +158,7 @@ begin
   result := true;
 end;
 
-function TDerIA5String.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerIA5String.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerIA5String;
 begin
@@ -206,12 +206,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerIA5String.Encode(derOut: IDerOutputStream);
+procedure TDerIA5String.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.IA5String, GetOctets());
 end;
 
-class function TDerIA5String.GetInstance(obj: IAsn1TaggedObject;
+class function TDerIA5String.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerIA5String;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerInteger.pas

@@ -51,19 +51,19 @@ type
     function GetValue: TBigInteger; inline;
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
 
     constructor Create(value: Int32); overload;
-    constructor Create(value: TBigInteger); overload;
+    constructor Create(const value: TBigInteger); overload;
     constructor Create(bytes: TCryptoLibByteArray); overload;
 
     property value: TBigInteger read GetValue;
     property PositiveValue: TBigInteger read GetPositiveValue;
     property bytes: TCryptoLibByteArray read GetBytes;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     function ToString(): String; override;
 
@@ -85,8 +85,8 @@ type
     // * @exception ArgumentException if the tagged object cannot
     // *               be converted.
     // */
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerInteger; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerInteger; overload; static; inline;
 
   end;
 
@@ -107,7 +107,7 @@ begin
 
 end;
 
-function TDerInteger.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerInteger.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerInteger;
 begin
@@ -126,7 +126,7 @@ begin
   Result := TArrayUtils.GetArrayHashCode(Fbytes);
 end;
 
-constructor TDerInteger.Create(value: TBigInteger);
+constructor TDerInteger.Create(const value: TBigInteger);
 begin
   inherited Create();
   if (not value.IsInitialized) then
@@ -160,7 +160,7 @@ begin
   Fbytes := System.Copy(bytes);
 end;
 
-procedure TDerInteger.Encode(derOut: IDerOutputStream);
+procedure TDerInteger.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.Integer, Fbytes);
 end;
@@ -170,7 +170,7 @@ begin
   Result := Fbytes;
 end;
 
-class function TDerInteger.GetInstance(obj: IAsn1TaggedObject;
+class function TDerInteger.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerInteger;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerNull.pas

@@ -49,12 +49,12 @@ type
 
   strict protected
     constructor Create(dummy: Int32);
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
     function Asn1GetHashCode(): Int32; override;
 
   public
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
     class property Instance: IDerNull read GetInstance;
 
   end;
@@ -63,7 +63,7 @@ implementation
 
 { TDerNull }
 
-function TDerNull.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerNull.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 begin
   result := Supports(asn1Object, IDerNull);
 end;
@@ -87,7 +87,7 @@ begin
   System.SetLength(FZeroBytes, 0);
 end;
 
-procedure TDerNull.Encode(derOut: IDerOutputStream);
+procedure TDerNull.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.Null, FZeroBytes);
 end;

CryptoLib/src/Asn1/ClpDerNumericString.pas

@@ -53,7 +53,7 @@ type
     property Str: String read GetStr;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -85,7 +85,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a Numeric string from the passed in object
@@ -114,8 +114,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerNumericString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerNumericString; overload; static; inline;
 
     /// <summary>
     /// Return true if the string can be represented as a NumericString
@@ -162,7 +162,7 @@ begin
   result := true;
 end;
 
-function TDerNumericString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerNumericString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerNumericString;
 begin
@@ -205,12 +205,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerNumericString.Encode(derOut: IDerOutputStream);
+procedure TDerNumericString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.NumericString, GetOctets());
 end;
 
-class function TDerNumericString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerNumericString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerNumericString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerObjectIdentifier.pas

@@ -67,7 +67,7 @@ type
     class constructor CreateDerObjectIdentifier();
     class destructor DestroyDerObjectIdentifier();
 
-    constructor Create(oid: IDerObjectIdentifier;
+    constructor Create(const oid: IDerObjectIdentifier;
       const branchID: String); overload;
     constructor Create(bytes: TCryptoLibByteArray); overload;
 
@@ -86,7 +86,7 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
     // /**
@@ -112,8 +112,8 @@ type
     // * @exception ArgumentException if the tagged object cannot
     // *               be converted.
     // */
-    class function GetInstance(obj: IAsn1TaggedObject; explicitly: Boolean)
-      : IDerObjectIdentifier; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      explicitly: Boolean): IDerObjectIdentifier; overload; static; inline;
 
     class function FromOctetString(enc: TCryptoLibByteArray)
       : IDerObjectIdentifier; static;
@@ -130,9 +130,9 @@ type
     // * @return  true if the branch is on the passed in stem, false otherwise.
     // */
 
-    function &On(stem: IDerObjectIdentifier): Boolean; virtual;
+    function &On(const stem: IDerObjectIdentifier): Boolean; virtual;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     function ToString(): String; override;
 
@@ -142,7 +142,8 @@ implementation
 
 { TDerObjectIdentifier }
 
-function TDerObjectIdentifier.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerObjectIdentifier.Asn1Equals(const asn1Object: IAsn1Object)
+  : Boolean;
 var
   other: IDerObjectIdentifier;
 begin
@@ -166,7 +167,7 @@ begin
   result := TDerObjectIdentifier.Create(Self as IDerObjectIdentifier, branchID);
 end;
 
-constructor TDerObjectIdentifier.Create(oid: IDerObjectIdentifier;
+constructor TDerObjectIdentifier.Create(const oid: IDerObjectIdentifier;
   const branchID: String);
 begin
   Inherited Create();
@@ -195,7 +196,7 @@ begin
   Fbody := System.Copy(bytes);
 end;
 
-function TDerObjectIdentifier.&On(stem: IDerObjectIdentifier): Boolean;
+function TDerObjectIdentifier.&On(const stem: IDerObjectIdentifier): Boolean;
 var
   LocalId, stemId: String;
 begin
@@ -251,7 +252,7 @@ begin
   end;
 end;
 
-procedure TDerObjectIdentifier.Encode(derOut: IDerOutputStream);
+procedure TDerObjectIdentifier.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.ObjectIdentifier, GetBody());
 end;
@@ -315,7 +316,7 @@ begin
   result := Fidentifier;
 end;
 
-class function TDerObjectIdentifier.GetInstance(obj: IAsn1TaggedObject;
+class function TDerObjectIdentifier.GetInstance(const obj: IAsn1TaggedObject;
   explicitly: Boolean): IDerObjectIdentifier;
 var
   o: IAsn1Object;
@@ -535,7 +536,6 @@ begin
   byteCount := (fieldValue.BitLength + 6) div 7;
   if (byteCount = 0) then
   begin
-    // outputStream.Write(TCryptoLibByteArray.Create(0)[0], 1);
     outputStream.WriteByte(0);
   end
   else

CryptoLib/src/Asn1/ClpDerOctetString.pas

@@ -34,13 +34,14 @@ type
   public
     /// <param name="str">The octets making up the octet string.</param>
     constructor Create(str: TCryptoLibByteArray); overload;
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     destructor Destroy(); override;
 
-    procedure Encode(derOut: IDerOutputStream); overload; override;
-    class procedure Encode(derOut: IDerOutputStream; bytes: TCryptoLibByteArray;
-      offset, length: Int32); reintroduce; overload; static; inline;
+    procedure Encode(const derOut: IDerOutputStream); overload; override;
+    class procedure Encode(const derOut: IDerOutputStream;
+      bytes: TCryptoLibByteArray; offset, length: Int32); reintroduce; overload;
+      static; inline;
 
   end;
 
@@ -53,7 +54,7 @@ begin
   Inherited Create(str);
 end;
 
-constructor TDerOctetString.Create(obj: IAsn1Encodable);
+constructor TDerOctetString.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(obj);
 end;
@@ -63,12 +64,12 @@ begin
   inherited Destroy;
 end;
 
-procedure TDerOctetString.Encode(derOut: IDerOutputStream);
+procedure TDerOctetString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.OctetString, str);
 end;
 
-class procedure TDerOctetString.Encode(derOut: IDerOutputStream;
+class procedure TDerOctetString.Encode(const derOut: IDerOutputStream;
   bytes: TCryptoLibByteArray; offset, length: Int32);
 begin
   derOut.WriteEncoded(TAsn1Tags.OctetString, bytes, offset, length);

CryptoLib/src/Asn1/ClpDerOutputStream.pas

@@ -49,8 +49,8 @@ type
       bytes: TCryptoLibByteArray); overload;
     procedure WriteTag(flags, tagNo: Int32);
 
-    procedure WriteObject(obj: IAsn1Encodable); overload; virtual;
-    procedure WriteObject(obj: IAsn1Object); overload; virtual;
+    procedure WriteObject(const obj: IAsn1Encodable); overload; virtual;
+    procedure WriteObject(const obj: IAsn1Object); overload; virtual;
 
   end;
 
@@ -134,7 +134,7 @@ begin
   WriteByte($00);
 end;
 
-procedure TDerOutputStream.WriteObject(obj: IAsn1Encodable);
+procedure TDerOutputStream.WriteObject(const obj: IAsn1Encodable);
 var
   asn1: IAsn1Object;
 begin
@@ -149,7 +149,7 @@ begin
   end;
 end;
 
-procedure TDerOutputStream.WriteObject(obj: IAsn1Object);
+procedure TDerOutputStream.WriteObject(const obj: IAsn1Object);
 begin
   if (obj = Nil) then
   begin

CryptoLib/src/Asn1/ClpDerPrintableString.pas

@@ -52,7 +52,7 @@ type
     function GetStr: String; inline;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -84,7 +84,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     property Str: String read GetStr;
 
@@ -115,8 +115,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerPrintableString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerPrintableString; overload; static; inline;
 
     /// <summary>
     /// return true if the passed in String can be represented without loss
@@ -181,7 +181,7 @@ begin
   result := true;
 end;
 
-function TDerPrintableString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerPrintableString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerPrintableString;
 begin
@@ -224,12 +224,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerPrintableString.Encode(derOut: IDerOutputStream);
+procedure TDerPrintableString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.PrintableString, GetOctets());
 end;
 
-class function TDerPrintableString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerPrintableString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerPrintableString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerSequence.pas

@@ -46,7 +46,8 @@ type
 
   public
 
-    class function FromVector(v: IAsn1EncodableVector): IDerSequence; static;
+    class function FromVector(const v: IAsn1EncodableVector)
+      : IDerSequence; static;
 
     /// <summary>
     /// create an empty sequence
@@ -56,14 +57,14 @@ type
     /// <summary>
     /// create a sequence containing one object
     /// </summary>
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     constructor Create(v: array of IAsn1Encodable); overload;
 
     /// <summary>
     /// create a sequence containing a vector of objects.
     /// </summary>
-    constructor Create(v: IAsn1EncodableVector); overload;
+    constructor Create(const v: IAsn1EncodableVector); overload;
 
     destructor Destroy(); override;
 
@@ -74,7 +75,7 @@ type
     /// just outputing Sequence, <br />we also have to specify Constructed,
     /// and the objects length. <br />
     /// </summary>
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     class property Empty: IDerSequence read GetEmpty;
 
@@ -84,7 +85,7 @@ implementation
 
 { TDerSequence }
 
-constructor TDerSequence.Create(obj: IAsn1Encodable);
+constructor TDerSequence.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(1);
   AddObject(obj);
@@ -95,7 +96,7 @@ begin
   Inherited Create(0);
 end;
 
-constructor TDerSequence.Create(v: IAsn1EncodableVector);
+constructor TDerSequence.Create(const v: IAsn1EncodableVector);
 var
   ae: IAsn1Encodable;
 begin
@@ -128,7 +129,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TDerSequence.Encode(derOut: IDerOutputStream);
+procedure TDerSequence.Encode(const derOut: IDerOutputStream);
 var
   bOut: TMemoryStream;
   dOut: TDerOutputStream;
@@ -156,7 +157,8 @@ begin
   derOut.WriteEncoded(TAsn1Tags.Sequence or TAsn1Tags.Constructed, bytes);
 end;
 
-class function TDerSequence.FromVector(v: IAsn1EncodableVector): IDerSequence;
+class function TDerSequence.FromVector(const v: IAsn1EncodableVector)
+  : IDerSequence;
 begin
   if v.Count < 1 then
   begin

CryptoLib/src/Asn1/ClpDerSequenceGenerator.pas

@@ -42,7 +42,7 @@ type
     constructor Create(outStream: TStream; tagNo: Int32;
       isExplicit: Boolean); overload;
     destructor Destroy(); override;
-    procedure AddObject(obj: IAsn1Encodable); override;
+    procedure AddObject(const obj: IAsn1Encodable); override;
     function GetRawOutputStream(): TStream; override;
     procedure Close(); override;
   end;
@@ -51,7 +51,7 @@ implementation
 
 { TDerSequenceGenerator }
 
-procedure TDerSequenceGenerator.AddObject(obj: IAsn1Encodable);
+procedure TDerSequenceGenerator.AddObject(const obj: IAsn1Encodable);
 var
   temp: TDerOutputStream;
 begin

CryptoLib/src/Asn1/ClpDerSequenceParser.pas

@@ -38,7 +38,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; inline;
 
@@ -48,7 +48,7 @@ implementation
 
 { TDerSequenceParser }
 
-constructor TDerSequenceParser.Create(parser: IAsn1StreamParser);
+constructor TDerSequenceParser.Create(const parser: IAsn1StreamParser);
 begin
   F_parser := parser;
 end;

CryptoLib/src/Asn1/ClpDerSet.pas

@@ -47,10 +47,10 @@ type
 
   public
 
-    class function FromVector(v: IAsn1EncodableVector): IDerSet;
+    class function FromVector(const v: IAsn1EncodableVector): IDerSet;
       overload; static;
-    class function FromVector(v: IAsn1EncodableVector; needsSorting: Boolean)
-      : IDerSet; overload; static;
+    class function FromVector(const v: IAsn1EncodableVector;
+      needsSorting: Boolean): IDerSet; overload; static;
 
     /// <summary>
     /// create an empty set
@@ -60,17 +60,17 @@ type
     /// <param name="obj">
     /// a single object that makes up the set.
     /// </param>
-    constructor Create(obj: IAsn1Encodable); overload;
+    constructor Create(const obj: IAsn1Encodable); overload;
 
     constructor Create(v: array of IAsn1Encodable); overload;
 
     /// <param name="v">
     /// a vector of objects making up the set.
     /// </param>
-    constructor Create(v: IAsn1EncodableVector); overload;
+    constructor Create(const v: IAsn1EncodableVector); overload;
 
-    constructor Create(v: IAsn1EncodableVector; needsSorting: Boolean);
-      overload;
+    constructor Create(const v: IAsn1EncodableVector;
+      needsSorting: Boolean); overload;
 
     destructor Destroy(); override;
 
@@ -81,7 +81,7 @@ type
     /// just outputing Set, <br />we also have to specify Constructed, and
     /// the objects length. <br />
     /// </summary>
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     class property Empty: IDerSet read GetEmpty;
 
@@ -109,7 +109,8 @@ begin
   Inherited Create(0);
 end;
 
-constructor TDerSet.Create(v: IAsn1EncodableVector; needsSorting: Boolean);
+constructor TDerSet.Create(const v: IAsn1EncodableVector;
+  needsSorting: Boolean);
 var
   o: IAsn1Encodable;
 begin
@@ -125,13 +126,13 @@ begin
   end;
 end;
 
-constructor TDerSet.Create(obj: IAsn1Encodable);
+constructor TDerSet.Create(const obj: IAsn1Encodable);
 begin
   Inherited Create(1);
   AddObject(obj);
 end;
 
-constructor TDerSet.Create(v: IAsn1EncodableVector);
+constructor TDerSet.Create(const v: IAsn1EncodableVector);
 begin
   Create(v, true);
 end;
@@ -147,7 +148,7 @@ begin
   inherited Destroy;
 end;
 
-procedure TDerSet.Encode(derOut: IDerOutputStream);
+procedure TDerSet.Encode(const derOut: IDerOutputStream);
 var
   bOut: TMemoryStream;
   dOut: TDerOutputStream;
@@ -175,7 +176,7 @@ begin
   derOut.WriteEncoded(TAsn1Tags.&Set or TAsn1Tags.Constructed, bytes);
 end;
 
-class function TDerSet.FromVector(v: IAsn1EncodableVector;
+class function TDerSet.FromVector(const v: IAsn1EncodableVector;
   needsSorting: Boolean): IDerSet;
 begin
   if v.Count < 1 then
@@ -193,7 +194,7 @@ begin
   result := FEmpty;
 end;
 
-class function TDerSet.FromVector(v: IAsn1EncodableVector): IDerSet;
+class function TDerSet.FromVector(const v: IAsn1EncodableVector): IDerSet;
 begin
   if v.Count < 1 then
   begin

CryptoLib/src/Asn1/ClpDerSetParser.pas

@@ -38,7 +38,7 @@ type
 
   public
 
-    constructor Create(parser: IAsn1StreamParser);
+    constructor Create(const parser: IAsn1StreamParser);
     function ReadObject(): IAsn1Convertible; inline;
     function ToAsn1Object(): IAsn1Object; inline;
 
@@ -48,7 +48,7 @@ implementation
 
 { TDerSetParser }
 
-constructor TDerSetParser.Create(parser: IAsn1StreamParser);
+constructor TDerSetParser.Create(const parser: IAsn1StreamParser);
 begin
   F_parser := parser;
 end;

CryptoLib/src/Asn1/ClpDerT61String.pas

@@ -51,7 +51,7 @@ type
     property Str: String read GetStr;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -68,7 +68,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a T61 string from the passed in object.
@@ -97,8 +97,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerT61String; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerT61String; overload; static; inline;
 
   end;
 
@@ -115,7 +115,7 @@ begin
 {$ENDIF FPC}
 end;
 
-function TDerT61String.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerT61String.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerT61String;
 begin
@@ -149,12 +149,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerT61String.Encode(derOut: IDerOutputStream);
+procedure TDerT61String.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.T61String, GetOctets());
 end;
 
-class function TDerT61String.GetInstance(obj: IAsn1TaggedObject;
+class function TDerT61String.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerT61String;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerTaggedObject.pas

@@ -49,7 +49,7 @@ type
     /// <param name="obj">
     /// the tagged object.
     /// </param>
-    constructor Create(tagNo: Int32; obj: IAsn1Encodable); overload;
+    constructor Create(tagNo: Int32; const obj: IAsn1Encodable); overload;
     /// <param name="explicitly">
     /// true if an explicitly tagged object.
     /// </param>
@@ -60,7 +60,7 @@ type
     /// the tagged object.
     /// </param>
     constructor Create(explicitly: Boolean; tagNo: Int32;
-      obj: IAsn1Encodable); overload;
+      const obj: IAsn1Encodable); overload;
 
     /// <summary>
     /// create an implicitly tagged object that contains a zero length
@@ -71,7 +71,7 @@ type
     /// </param>
     constructor Create(tagNo: Int32); overload;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
   end;
 
@@ -79,13 +79,13 @@ implementation
 
 { TDerTaggedObject }
 
-constructor TDerTaggedObject.Create(tagNo: Int32; obj: IAsn1Encodable);
+constructor TDerTaggedObject.Create(tagNo: Int32; const obj: IAsn1Encodable);
 begin
   Inherited Create(tagNo, obj);
 end;
 
 constructor TDerTaggedObject.Create(explicitly: Boolean; tagNo: Int32;
-  obj: IAsn1Encodable);
+  const obj: IAsn1Encodable);
 begin
   Inherited Create(explicitly, tagNo, obj)
 end;
@@ -95,7 +95,7 @@ begin
   Inherited Create(false, tagNo, TDerSequence.Empty)
 end;
 
-procedure TDerTaggedObject.Encode(derOut: IDerOutputStream);
+procedure TDerTaggedObject.Encode(const derOut: IDerOutputStream);
 var
   bytes: TCryptoLibByteArray;
   flags: Int32;

CryptoLib/src/Asn1/ClpDerUniversalString.pas

@@ -57,7 +57,7 @@ type
     property Str: TCryptoLibByteArray read GetStr;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -69,7 +69,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a Universal String from the passed in object.
@@ -98,8 +98,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerUniversalString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerUniversalString; overload; static; inline;
 
   end;
 
@@ -112,7 +112,7 @@ begin
   result := System.Copy(Str);
 end;
 
-function TDerUniversalString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerUniversalString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerUniversalString;
 begin
@@ -137,12 +137,12 @@ begin
   FStr := Str;
 end;
 
-procedure TDerUniversalString.Encode(derOut: IDerOutputStream);
+procedure TDerUniversalString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.UniversalString, Str);
 end;
 
-class function TDerUniversalString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerUniversalString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerUniversalString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerUtf8String.pas

@@ -51,7 +51,7 @@ type
     property Str: String read GetStr;
 
   strict protected
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -68,7 +68,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return an UTF8 string from the passed in object.
@@ -97,8 +97,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerUtf8String; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerUtf8String; overload; static; inline;
 
   end;
 
@@ -115,7 +115,7 @@ begin
 {$ENDIF FPC}
 end;
 
-function TDerUtf8String.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerUtf8String.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerUtf8String;
 begin
@@ -149,7 +149,7 @@ begin
   FStr := Str;
 end;
 
-procedure TDerUtf8String.Encode(derOut: IDerOutputStream);
+procedure TDerUtf8String.Encode(const derOut: IDerOutputStream);
 begin
 {$IFDEF FPC}
   derOut.WriteEncoded(TAsn1Tags.Utf8String,
@@ -159,7 +159,7 @@ begin
 {$ENDIF FPC}
 end;
 
-class function TDerUtf8String.GetInstance(obj: IAsn1TaggedObject;
+class function TDerUtf8String.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerUtf8String;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerVideotexString.pas

@@ -48,7 +48,7 @@ type
 
   protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
 
   public
     property mString: TCryptoLibByteArray read GetmString;
@@ -65,7 +65,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a Videotex String from the passed in object
@@ -97,8 +97,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerVideotexString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerVideotexString; overload; static; inline;
 
   end;
 
@@ -106,7 +106,7 @@ implementation
 
 { TDerVideotexString }
 
-function TDerVideotexString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerVideotexString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerVideotexString;
 begin
@@ -131,7 +131,7 @@ begin
   FmString := System.Copy(encoding);
 end;
 
-procedure TDerVideotexString.Encode(derOut: IDerOutputStream);
+procedure TDerVideotexString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.VideotexString, mString);
 end;
@@ -148,7 +148,7 @@ begin
     [obj.ClassName]);
 end;
 
-class function TDerVideotexString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerVideotexString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerVideotexString;
 var
   o: IAsn1Object;

CryptoLib/src/Asn1/ClpDerVisibleString.pas

@@ -53,7 +53,7 @@ type
 
   strict protected
     function Asn1GetHashCode(): Int32; override;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean; override;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean; override;
   public
 
     /// <summary>
@@ -70,7 +70,7 @@ type
 
     function GetOctets(): TCryptoLibByteArray; inline;
 
-    procedure Encode(derOut: IDerOutputStream); override;
+    procedure Encode(const derOut: IDerOutputStream); override;
 
     /// <summary>
     /// return a DerVisibleString from the passed in object
@@ -99,8 +99,8 @@ type
     /// <exception cref="ClpCryptoLibTypes|EArgumentCryptoLibException">
     /// if the tagged object cannot be converted.
     /// </exception>
-    class function GetInstance(obj: IAsn1TaggedObject; isExplicit: Boolean)
-      : IDerVisibleString; overload; static; inline;
+    class function GetInstance(const obj: IAsn1TaggedObject;
+      isExplicit: Boolean): IDerVisibleString; overload; static; inline;
 
   end;
 
@@ -117,7 +117,7 @@ begin
 {$ENDIF FPC}
 end;
 
-function TDerVisibleString.Asn1Equals(asn1Object: IAsn1Object): Boolean;
+function TDerVisibleString.Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 var
   other: IDerVisibleString;
 begin
@@ -156,14 +156,14 @@ begin
   FStr := Str;
 end;
 
-procedure TDerVisibleString.Encode(derOut: IDerOutputStream);
+procedure TDerVisibleString.Encode(const derOut: IDerOutputStream);
 begin
   derOut.WriteEncoded(TAsn1Tags.VisibleString, GetOctets());
 end;
 
 {$IFNDEF _FIXINSIGHT_}
 
-class function TDerVisibleString.GetInstance(obj: IAsn1TaggedObject;
+class function TDerVisibleString.GetInstance(const obj: IAsn1TaggedObject;
   isExplicit: Boolean): IDerVisibleString;
 begin
   result := GetInstance(obj.GetObject() as TAsn1Object);

CryptoLib/src/Asn1/CryptoPro/ClpECGost3410NamedCurves.pas

@@ -57,8 +57,8 @@ type
     // *
     // * @param oid an object identifier representing a named parameters, if present.
     // */
-    class function GetByOid(oid: IDerObjectIdentifier): IECDomainParameters;
-      static; inline;
+    class function GetByOid(const oid: IDerObjectIdentifier)
+      : IECDomainParameters; static; inline;
     // /**
     // * return the ECDomainParameters object for the given OID, null if it
     // * isn't present.
@@ -70,7 +70,8 @@ type
     // /**
     // * return the named curve name represented by the given object identifier.
     // */
-    class function GetName(oid: IDerObjectIdentifier): String; static; inline;
+    class function GetName(const oid: IDerObjectIdentifier): String;
+      static; inline;
 
     class function GetOid(const name: String): IDerObjectIdentifier;
       static; inline;
@@ -381,14 +382,14 @@ begin
   Result := Nil;
 end;
 
-class function TECGost3410NamedCurves.GetByOid(oid: IDerObjectIdentifier)
+class function TECGost3410NamedCurves.GetByOid(const oid: IDerObjectIdentifier)
   : IECDomainParameters;
 begin
   Fparameters.TryGetValue(oid, Result);
 end;
 
 class function TECGost3410NamedCurves.GetName
-  (oid: IDerObjectIdentifier): String;
+  (const oid: IDerObjectIdentifier): String;
 begin
   Fnames.TryGetValue(oid, Result);
 end;

CryptoLib/src/Asn1/Sec/ClpSecNamedCurves.pas

@@ -53,12 +53,14 @@ type
     Fcurves: TDictionary<IDerObjectIdentifier, IX9ECParametersHolder>;
 
     class function GetNames: TCryptoLibStringArray; static; inline;
-    class procedure DefineCurve(const name: String; oid: IDerObjectIdentifier;
-      holder: IX9ECParametersHolder); static; inline;
-
-    class function ConfigureCurve(curve: IECCurve): IECCurve; static; inline;
-    class function ConfigureCurveGlv(c: IECCurve; p: IGlvTypeBParameters)
-      : IECCurve; static; inline;
+    class procedure DefineCurve(const name: String;
+      const oid: IDerObjectIdentifier; const holder: IX9ECParametersHolder);
+      static; inline;
+
+    class function ConfigureCurve(const curve: IECCurve): IECCurve;
+      static; inline;
+    class function ConfigureCurveGlv(const c: IECCurve;
+      const p: IGlvTypeBParameters): IECCurve; static; inline;
     class function FromHex(const Hex: String): TBigInteger; static; inline;
 
   public
@@ -69,7 +71,8 @@ type
     // *
     // * @param oid an object identifier representing a named curve, if present.
     // */
-    class function GetByOid(oid: IDerObjectIdentifier): IX9ECParameters; static;
+    class function GetByOid(const oid: IDerObjectIdentifier)
+      : IX9ECParameters; static;
     // /**
     // * return the object identifier signified by the passed in name. Null
     // * if there is no object identifier associated with name.
@@ -80,7 +83,8 @@ type
     // /**
     // * return the named curve name represented by the given object identifier.
     // */
-    class function GetName(oid: IDerObjectIdentifier): String; static; inline;
+    class function GetName(const oid: IDerObjectIdentifier): String;
+      static; inline;
     // /**
     // * returns an enumeration containing the name strings for curves
     // * contained in this structure.
@@ -168,24 +172,24 @@ implementation
 { TSecNamedCurves }
 
 class procedure TSecNamedCurves.DefineCurve(const name: String;
-  oid: IDerObjectIdentifier; holder: IX9ECParametersHolder);
+  const oid: IDerObjectIdentifier; const holder: IX9ECParametersHolder);
 begin
   FobjIds.Add(UpperCase(name), oid);
   Fnames.Add(oid, name);
   Fcurves.Add(oid, holder);
 end;
 
-class function TSecNamedCurves.ConfigureCurve(curve: IECCurve): IECCurve;
+class function TSecNamedCurves.ConfigureCurve(const curve: IECCurve): IECCurve;
 begin
   result := curve;
 end;
 
-class function TSecNamedCurves.ConfigureCurveGlv(c: IECCurve;
-  p: IGlvTypeBParameters): IECCurve;
+class function TSecNamedCurves.ConfigureCurveGlv(const c: IECCurve;
+  const p: IGlvTypeBParameters): IECCurve;
 var
   glv: IGlvTypeBEndomorphism;
 begin
-  glv := TGlvTypeBEndomorphism.Create(c, p) as IGlvTypeBEndomorphism;
+  glv := TGlvTypeBEndomorphism.Create(c, p);
   result := c.Configure().SetEndomorphism(glv).CreateCurve();
 end;
 
@@ -218,7 +222,7 @@ begin
   result := TBigInteger.Create(1, THex.Decode(Hex));
 end;
 
-class function TSecNamedCurves.GetByOid(oid: IDerObjectIdentifier)
+class function TSecNamedCurves.GetByOid(const oid: IDerObjectIdentifier)
   : IX9ECParameters;
 var
   holder: IX9ECParametersHolder;
@@ -257,7 +261,7 @@ begin
 
 end;
 
-class function TSecNamedCurves.GetName(oid: IDerObjectIdentifier): String;
+class function TSecNamedCurves.GetName(const oid: IDerObjectIdentifier): String;
 begin
   if not(Fnames.TryGetValue(oid, result)) then
   begin
@@ -303,7 +307,7 @@ begin
     TBigInteger.Create('3086d221a7d46bcde86c90e49284eb153dab', 16),
     TBigInteger.Create('e4437ed6010e88286f547fa90abfe4c42212', 16), 272);
 
-  curve := ConfigureCurveGlv(TFpCurve.Create(p, a, b, n, h), glv);
+  curve := ConfigureCurveGlv(TFpCurve.Create(p, a, b, n, h) as IFpCurve, glv);
   G := TX9ECPoint.Create(curve,
     THex.Decode('04' +
     '79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798' +
@@ -338,7 +342,7 @@ begin
     ('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973');
   h := TBigInteger.One;
 
-  curve := ConfigureCurve(TFpCurve.Create(p, a, b, n, h));
+  curve := ConfigureCurve(TFpCurve.Create(p, a, b, n, h) as IFpCurve);
   G := TX9ECPoint.Create(curve,
     THex.Decode('04' +
     'AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7'
@@ -402,7 +406,7 @@ begin
     ('01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409');
   h := TBigInteger.One;
 
-  curve := ConfigureCurve(TFpCurve.Create(p, a, b, n, h));
+  curve := ConfigureCurve(TFpCurve.Create(p, a, b, n, h) as IFpCurve);
   G := TX9ECPoint.Create(curve,
     THex.Decode('04' +
     '00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66'

CryptoLib/src/Asn1/X9/ClpECNamedCurveTable.pas

@@ -41,7 +41,7 @@ type
   strict private
 
     class function GetNames: TCryptoLibStringArray; static;
-    class function FromDomainParameters(dp: IECDomainParameters)
+    class function FromDomainParameters(const dp: IECDomainParameters)
       : IX9ECParameters; static; inline;
 
   public
@@ -54,7 +54,7 @@ type
     // */
     class function GetByName(const name: String): IX9ECParameters; static;
 
-    class function GetName(oid: IDerObjectIdentifier): String; static;
+    class function GetName(const oid: IDerObjectIdentifier): String; static;
     // /**
     // * return the object identifier signified by the passed in name. Null
     // * if there is no object identifier associated with name.
@@ -71,7 +71,8 @@ type
     // * @return an X9ECParameters object or null if the curve is not available.
     // */
 
-    class function GetByOid(oid: IDerObjectIdentifier): IX9ECParameters; static;
+    class function GetByOid(const oid: IDerObjectIdentifier)
+      : IX9ECParameters; static;
 
     // /**
     // * return an enumeration of the names of the available curves.
@@ -86,8 +87,8 @@ implementation
 
 { TECNamedCurveTable }
 
-class function TECNamedCurveTable.FromDomainParameters(dp: IECDomainParameters)
-  : IX9ECParameters;
+class function TECNamedCurveTable.FromDomainParameters
+  (const dp: IECDomainParameters): IX9ECParameters;
 begin
   if dp = Nil then
   begin
@@ -114,7 +115,7 @@ begin
   result := ecP;
 end;
 
-class function TECNamedCurveTable.GetByOid(oid: IDerObjectIdentifier)
+class function TECNamedCurveTable.GetByOid(const oid: IDerObjectIdentifier)
   : IX9ECParameters;
 var
   ecP: IX9ECParameters;
@@ -127,7 +128,8 @@ begin
   result := ecP;
 end;
 
-class function TECNamedCurveTable.GetName(oid: IDerObjectIdentifier): String;
+class function TECNamedCurveTable.GetName
+  (const oid: IDerObjectIdentifier): String;
 var
   name: String;
 begin

CryptoLib/src/Asn1/X9/ClpX9Curve.pas

@@ -68,9 +68,11 @@ type
     function GetCurve: IECCurve; inline;
 
   public
-    constructor Create(curve: IECCurve); overload;
-    constructor Create(curve: IECCurve; seed: TCryptoLibByteArray); overload;
-    constructor Create(fieldID: IX9FieldID; seq: IAsn1Sequence); overload;
+    constructor Create(const curve: IECCurve); overload;
+    constructor Create(const curve: IECCurve;
+      seed: TCryptoLibByteArray); overload;
+    constructor Create(const fieldID: IX9FieldID;
+      const seq: IAsn1Sequence); overload;
 
     function GetSeed(): TCryptoLibByteArray; inline;
 
@@ -97,7 +99,7 @@ implementation
 
 { TX9Curve }
 
-constructor TX9Curve.Create(curve: IECCurve; seed: TCryptoLibByteArray);
+constructor TX9Curve.Create(const curve: IECCurve; seed: TCryptoLibByteArray);
 begin
   Inherited Create();
   if (curve = Nil) then
@@ -122,12 +124,13 @@ begin
   end;
 end;
 
-constructor TX9Curve.Create(curve: IECCurve);
+constructor TX9Curve.Create(const curve: IECCurve);
 begin
   Create(curve, Nil);
 end;
 
-constructor TX9Curve.Create(fieldID: IX9FieldID; seq: IAsn1Sequence);
+constructor TX9Curve.Create(const fieldID: IX9FieldID;
+  const seq: IAsn1Sequence);
 var
   q: TBigInteger;
   x9A, x9B: IX9FieldElement;
@@ -215,13 +218,15 @@ begin
   if (FfieldIdentifier.Equals(TX9ObjectIdentifiers.PrimeField) or
     FfieldIdentifier.Equals(TX9ObjectIdentifiers.CharacteristicTwoField)) then
   begin
-    v.Add([TX9FieldElement.Create(Fcurve.A).ToAsn1Object()]);
-    v.Add([TX9FieldElement.Create(Fcurve.B).ToAsn1Object()]);
+    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)]);
+    v.Add([TDerBitString.Create(FSeed) as IDerBitString]);
   end;
 
   result := TDerSequence.Create(v);

CryptoLib/src/Asn1/X9/ClpX9ECParameters.pas

@@ -77,16 +77,17 @@ type
 
   public
 
-    constructor Create(seq: IAsn1Sequence); overload;
-    constructor Create(curve: IECCurve; g: IECPoint; n: TBigInteger); overload;
-    constructor Create(curve: IECCurve; g: IX9ECPoint;
-      n, h: TBigInteger); overload;
-    constructor Create(curve: IECCurve; g: IECPoint;
-      n, h: TBigInteger); overload;
-    constructor Create(curve: IECCurve; g: IECPoint; n, h: TBigInteger;
-      seed: TCryptoLibByteArray); overload;
-    constructor Create(curve: IECCurve; g: IX9ECPoint; n, h: TBigInteger;
-      seed: TCryptoLibByteArray); overload;
+    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; seed: TCryptoLibByteArray); overload;
+    constructor Create(const curve: IECCurve; const g: IX9ECPoint;
+      const n, h: TBigInteger; seed: TCryptoLibByteArray); overload;
 
     property curve: IECCurve read GetCurve;
     property g: IECPoint read GetG;
@@ -108,19 +109,19 @@ implementation
 
 { TX9ECParameters }
 
-constructor TX9ECParameters.Create(curve: IECCurve; g: IX9ECPoint;
-  n, h: TBigInteger);
+constructor TX9ECParameters.Create(const curve: IECCurve; const g: IX9ECPoint;
+  const n, h: TBigInteger);
 begin
   Create(curve, g, n, h, Nil);
 end;
 
-constructor TX9ECParameters.Create(curve: IECCurve; g: IECPoint;
-  n: TBigInteger);
+constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n: TBigInteger);
 begin
   Create(curve, g, n, Default (TBigInteger), Nil);
 end;
 
-constructor TX9ECParameters.Create(seq: IAsn1Sequence);
+constructor TX9ECParameters.Create(const seq: IAsn1Sequence);
 var
   x9c: IX9Curve;
   p: TObject;
@@ -159,8 +160,8 @@ begin
   end;
 end;
 
-constructor TX9ECParameters.Create(curve: IECCurve; g: IX9ECPoint;
-  n, h: TBigInteger; seed: TCryptoLibByteArray);
+constructor TX9ECParameters.Create(const curve: IECCurve; const g: IX9ECPoint;
+  const n, h: TBigInteger; seed: TCryptoLibByteArray);
 var
   exponents: TCryptoLibInt32Array;
   Field: IPolynomialExtensionField;
@@ -202,14 +203,14 @@ begin
   end;
 end;
 
-constructor TX9ECParameters.Create(curve: IECCurve; g: IECPoint;
-  n, h: TBigInteger; seed: TCryptoLibByteArray);
+constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n, h: TBigInteger; seed: TCryptoLibByteArray);
 begin
-  Create(curve, TX9ECPoint.Create(g), n, h, seed)
+  Create(curve, TX9ECPoint.Create(g) as IX9ECPoint, n, h, seed)
 end;
 
-constructor TX9ECParameters.Create(curve: IECCurve; g: IECPoint;
-  n, h: TBigInteger);
+constructor TX9ECParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n, h: TBigInteger);
 begin
   Create(curve, g, n, h, Nil);
 end;
@@ -293,12 +294,14 @@ var
   v: IAsn1EncodableVector;
 begin
 
-  v := TAsn1EncodableVector.Create([TDerInteger.Create(TBigInteger.One),
-    FfieldID, TX9Curve.Create(Fcurve, Fseed), Fg, TDerInteger.Create(Fn)]);
+  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)]);
+    v.Add([TDerInteger.Create(Fh) as IDerInteger]);
   end;
 
   Result := TDerSequence.Create(v);

CryptoLib/src/Asn1/X9/ClpX9ECPoint.pas

@@ -47,10 +47,11 @@ type
 
   public
 
-    constructor Create(p: IECPoint); overload;
-    constructor Create(p: IECPoint; compressed: Boolean); overload;
-    constructor Create(c: IECCurve; encoding: TCryptoLibByteArray); overload;
-    constructor Create(c: IECCurve; s: IAsn1OctetString); overload;
+    constructor Create(const p: IECPoint); overload;
+    constructor Create(const p: IECPoint; compressed: Boolean); overload;
+    constructor Create(const c: IECCurve;
+      encoding: TCryptoLibByteArray); overload;
+    constructor Create(const c: IECCurve; const s: IAsn1OctetString); overload;
 
     property Point: IECPoint read GetPoint;
     property IsPointCompressed: Boolean read GetIsPointCompressed;
@@ -73,26 +74,26 @@ implementation
 
 { TX9ECPoint }
 
-constructor TX9ECPoint.Create(c: IECCurve; encoding: TCryptoLibByteArray);
+constructor TX9ECPoint.Create(const c: IECCurve; encoding: TCryptoLibByteArray);
 begin
   inherited Create();
   Fc := c;
   Fencoding := TDerOctetString.Create(System.Copy(encoding));
 end;
 
-constructor TX9ECPoint.Create(p: IECPoint; compressed: Boolean);
+constructor TX9ECPoint.Create(const p: IECPoint; compressed: Boolean);
 begin
   inherited Create();
   Fp := p.Normalize();
   Fencoding := TDerOctetString.Create(p.GetEncoded(compressed));
 end;
 
-constructor TX9ECPoint.Create(p: IECPoint);
+constructor TX9ECPoint.Create(const p: IECPoint);
 begin
   Create(p, false);
 end;
 
-constructor TX9ECPoint.Create(c: IECCurve; s: IAsn1OctetString);
+constructor TX9ECPoint.Create(const c: IECCurve; const s: IAsn1OctetString);
 begin
   Create(c, s.GetOctets());
 end;

CryptoLib/src/Asn1/X9/ClpX9FieldElement.pas

@@ -47,9 +47,11 @@ type
     function GetValue: IECFieldElement; inline;
 
   public
-    constructor Create(f: IECFieldElement); overload;
-    constructor Create(p: TBigInteger; s: IAsn1OctetString); overload;
-    constructor Create(m, k1, k2, k3: Int32; s: IAsn1OctetString); overload;
+    constructor Create(const f: IECFieldElement); overload;
+    constructor Create(const p: TBigInteger;
+      const s: IAsn1OctetString); overload;
+    constructor Create(m, k1, k2, k3: Int32;
+      const s: IAsn1OctetString); overload;
 
     // /**
     // * Produce an object suitable for an Asn1OutputStream.
@@ -78,21 +80,23 @@ implementation
 
 { TX9FieldElement }
 
-constructor TX9FieldElement.Create(p: TBigInteger; s: IAsn1OctetString);
+constructor TX9FieldElement.Create(const p: TBigInteger;
+  const s: IAsn1OctetString);
 begin
   Create(TFpFieldElement.Create(p, TBigInteger.Create(1, s.GetOctets())))
 end;
 
-constructor TX9FieldElement.Create(f: IECFieldElement);
+constructor TX9FieldElement.Create(const f: IECFieldElement);
 begin
   Inherited Create();
   Ff := f;
 end;
 
-constructor TX9FieldElement.Create(m, k1, k2, k3: Int32; s: IAsn1OctetString);
+constructor TX9FieldElement.Create(m, k1, k2, k3: Int32;
+  const s: IAsn1OctetString);
 begin
   Create(TF2mFieldElement.Create(m, k1, k2, k3, TBigInteger.Create(1,
-    s.GetOctets())))
+    s.GetOctets())) as IF2mFieldElement)
 end;
 
 function TX9FieldElement.GetValue: IECFieldElement;

CryptoLib/src/Asn1/X9/ClpX9FieldID.pas

@@ -22,6 +22,7 @@ interface
 uses
   ClpCryptoLibTypes,
   ClpIX9FieldID,
+  ClpIDerInteger,
   ClpAsn1Sequence,
   ClpIAsn1Sequence,
   ClpAsn1EncodableVector,
@@ -54,7 +55,7 @@ type
     function GetIdentifier: IDerObjectIdentifier; inline;
     function GetParameters: IAsn1Object; inline;
 
-    constructor Create(seq: IAsn1Sequence); overload;
+    constructor Create(const seq: IAsn1Sequence); overload;
 
   public
     // /**
@@ -62,7 +63,7 @@ type
     // * <code>F<sub>2</sub></code>.
     // * @param primeP The prime <code>p</code> defining the prime field.
     // */
-    constructor Create(primeP: TBigInteger); overload;
+    constructor Create(const primeP: TBigInteger); overload;
     // /**
     // * Constructor for elliptic curves over binary fields
     // * <code>F<sub>2<sup>m</sup></sub></code>.
@@ -122,14 +123,14 @@ begin
   Create(m, k1, 0, 0);
 end;
 
-constructor TX9FieldID.Create(primeP: TBigInteger);
+constructor TX9FieldID.Create(const primeP: TBigInteger);
 begin
   Inherited Create();
   Fid := TX9ObjectIdentifiers.PrimeField;
   Fparameters := TDerInteger.Create(primeP);
 end;
 
-constructor TX9FieldID.Create(seq: IAsn1Sequence);
+constructor TX9FieldID.Create(const seq: IAsn1Sequence);
 begin
   Inherited Create();
   Fid := TDerObjectIdentifier.GetInstance(seq[0] as TAsn1Sequence);
@@ -143,7 +144,8 @@ begin
   inherited Create();
   Fid := TX9ObjectIdentifiers.CharacteristicTwoField;
 
-  fieldIdParams := TAsn1EncodableVector.Create([TDerInteger.Create(m)]);
+  fieldIdParams := TAsn1EncodableVector.Create
+    ([TDerInteger.Create(m) as IDerInteger]);
 
   if (k2 = 0) then
   begin
@@ -152,7 +154,8 @@ begin
       raise EArgumentCryptoLibException.CreateRes(@SInconsistentKValues);
     end;
 
-    fieldIdParams.Add([TX9ObjectIdentifiers.TPBasis, TDerInteger.Create(k1)]);
+    fieldIdParams.Add([TX9ObjectIdentifiers.TPBasis, TDerInteger.Create(k1)
+      as IDerInteger]);
   end
   else
   begin
@@ -163,8 +166,9 @@ begin
     end;
 
     fieldIdParams.Add([TX9ObjectIdentifiers.PPBasis,
-      TDerSequence.Create([TDerInteger.Create(k1), TDerInteger.Create(k2),
-      TDerInteger.Create(k3)])]);
+      TDerSequence.Create([TDerInteger.Create(k1) as IDerInteger,
+      TDerInteger.Create(k2) as IDerInteger, TDerInteger.Create(k3)
+      as IDerInteger])]);
   end;
 
   Fparameters := TDerSequence.Create(fieldIdParams);

CryptoLib/src/Asn1/X9/ClpX9IntegerConverter.pas

@@ -30,11 +30,12 @@ type
 
   public
 
-    class function GetByteLength(fe: IECFieldElement): Int32; overload;
+    class function GetByteLength(const fe: IECFieldElement): Int32; overload;
+      static; inline;
+    class function GetByteLength(const c: IECCurve): Int32; overload;
       static; inline;
-    class function GetByteLength(c: IECCurve): Int32; overload; static; inline;
 
-    class function IntegerToBytes(s: TBigInteger; qLength: Int32)
+    class function IntegerToBytes(const s: TBigInteger; qLength: Int32)
       : TCryptoLibByteArray; static;
 
   end;
@@ -43,17 +44,18 @@ implementation
 
 { TX9IntegerConverter }
 
-class function TX9IntegerConverter.GetByteLength(fe: IECFieldElement): Int32;
+class function TX9IntegerConverter.GetByteLength
+  (const fe: IECFieldElement): Int32;
 begin
   result := (fe.FieldSize + 7) div 8;
 end;
 
-class function TX9IntegerConverter.GetByteLength(c: IECCurve): Int32;
+class function TX9IntegerConverter.GetByteLength(const c: IECCurve): Int32;
 begin
   result := (c.FieldSize + 7) div 8;
 end;
 
-class function TX9IntegerConverter.IntegerToBytes(s: TBigInteger;
+class function TX9IntegerConverter.IntegerToBytes(const s: TBigInteger;
   qLength: Int32): TCryptoLibByteArray;
 var
   bytes, tmp: TCryptoLibByteArray;

CryptoLib/src/Crypto/ClpAsymmetricCipherKeyPair.pas

@@ -55,7 +55,7 @@ type
     /// <param name="privateParameter">
     /// privateParam the corresponding private key parameters.
     /// </param>
-    constructor Create(publicParameter, privateParameter
+    constructor Create(const publicParameter, privateParameter
       : IAsymmetricKeyParameter);
 
     /// <summary>
@@ -74,8 +74,8 @@ implementation
 
 { TAsymmetricCipherKeyPair }
 
-constructor TAsymmetricCipherKeyPair.Create(publicParameter, privateParameter
-  : IAsymmetricKeyParameter);
+constructor TAsymmetricCipherKeyPair.Create(const publicParameter,
+  privateParameter: IAsymmetricKeyParameter);
 begin
   if (publicParameter.IsPrivate) then
   begin

CryptoLib/src/Crypto/ClpAsymmetricKeyParameter.pas

@@ -42,7 +42,7 @@ type
   public
     property IsPrivate: Boolean read GetIsPrivate;
     property privateKey: Boolean read GetPrivateKey;
-    function Equals(other: IAsymmetricKeyParameter): Boolean; reintroduce;
+    function Equals(const other: IAsymmetricKeyParameter): Boolean; reintroduce;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -57,8 +57,8 @@ begin
   FprivateKey := privateKey;
 end;
 
-function TAsymmetricKeyParameter.Equals(other: IAsymmetricKeyParameter)
-  : Boolean;
+function TAsymmetricKeyParameter.Equals(const other
+  : IAsymmetricKeyParameter): Boolean;
 begin
   if (other = Nil) then
   begin

CryptoLib/src/Crypto/ClpKeyGenerationParameters.pas

@@ -73,7 +73,7 @@ type
     /// <param name="Strength">
     /// the size, in bits, of the keys we want to produce.
     /// </param>
-    constructor Create(Random: ISecureRandom; Strength: Int32);
+    constructor Create(const Random: ISecureRandom; Strength: Int32);
 
   end;
 
@@ -81,7 +81,7 @@ implementation
 
 { TKeyGenerationParameters }
 
-constructor TKeyGenerationParameters.Create(Random: ISecureRandom;
+constructor TKeyGenerationParameters.Create(const Random: ISecureRandom;
   Strength: Int32);
 begin
   if (Random = Nil) then

CryptoLib/src/Crypto/Generators/ClpECKeyPairGenerator.pas

@@ -35,6 +35,7 @@ uses
   ClpECDomainParameters,
   ClpIECDomainParameters,
   ClpIECInterface,
+  ClpIFixedPointCombMultiplier,
   ClpSecObjectIdentifiers,
   // ClpCustomNamedCurves,
   ClpECNamedCurveTable,
@@ -74,18 +75,18 @@ type
     constructor Create(); overload;
     constructor Create(const algorithm: String); overload;
 
-    procedure Init(parameters: IKeyGenerationParameters);
+    procedure Init(const parameters: IKeyGenerationParameters);
     // /**
     // * Given the domain parameters this routine generates an EC key
     // * pair in accordance with X9.62 section 5.2.1 pages 26, 27.
     // */
     function GenerateKeyPair(): IAsymmetricCipherKeyPair;
 
-    class function FindECCurveByOid(oid: IDerObjectIdentifier)
+    class function FindECCurveByOid(const oid: IDerObjectIdentifier)
       : IX9ECParameters; static;
 
-    class function GetCorrespondingPublicKey(privKey: IECPrivateKeyParameters)
-      : IECPublicKeyParameters; static;
+    class function GetCorrespondingPublicKey(const privKey
+      : IECPrivateKeyParameters): IECPublicKeyParameters; static;
 
   end;
 
@@ -111,8 +112,8 @@ begin
   result := TFixedPointCombMultiplier.Create();
 end;
 
-class function TECKeyPairGenerator.FindECCurveByOid(oid: IDerObjectIdentifier)
-  : IX9ECParameters;
+class function TECKeyPairGenerator.FindECCurveByOid
+  (const oid: IDerObjectIdentifier): IX9ECParameters;
 var
   ecP: IX9ECParameters;
 begin
@@ -156,24 +157,27 @@ begin
   if (FpublicKeyParamSet <> Nil) then
   begin
     result := TAsymmetricCipherKeyPair.Create
-      (TECPublicKeyParameters.Create(Falgorithm, q, FpublicKeyParamSet),
-      TECPrivateKeyParameters.Create(Falgorithm, d, FpublicKeyParamSet));
+      (TECPublicKeyParameters.Create(Falgorithm, q, FpublicKeyParamSet)
+      as IECPublicKeyParameters, TECPrivateKeyParameters.Create(Falgorithm, d,
+      FpublicKeyParamSet) as IECPrivateKeyParameters);
     Exit;
   end;
 
   result := TAsymmetricCipherKeyPair.Create
-    (TECPublicKeyParameters.Create(Falgorithm, q, Fparameters),
-    TECPrivateKeyParameters.Create(Falgorithm, d, Fparameters));
+    (TECPublicKeyParameters.Create(Falgorithm, q, Fparameters)
+    as IECPublicKeyParameters, TECPrivateKeyParameters.Create(Falgorithm, d,
+    Fparameters) as IECPrivateKeyParameters);
 end;
 
 class function TECKeyPairGenerator.GetCorrespondingPublicKey
-  (privKey: IECPrivateKeyParameters): IECPublicKeyParameters;
+  (const privKey: IECPrivateKeyParameters): IECPublicKeyParameters;
 var
   ec: IECDomainParameters;
   q: IECPoint;
 begin
   ec := privKey.parameters;
-  q := TFixedPointCombMultiplier.Create().Multiply(ec.G, privKey.d);
+  q := (TFixedPointCombMultiplier.Create() as IFixedPointCombMultiplier)
+    .Multiply(ec.G, privKey.d);
 
   if (privKey.publicKeyParamSet <> Nil) then
   begin
@@ -185,7 +189,7 @@ begin
   result := TECPublicKeyParameters.Create(privKey.AlgorithmName, q, ec);
 end;
 
-procedure TECKeyPairGenerator.Init(parameters: IKeyGenerationParameters);
+procedure TECKeyPairGenerator.Init(const parameters: IKeyGenerationParameters);
 var
   ecP: IECKeyGenerationParameters;
   ecps: IX9ECParameters;

CryptoLib/src/Crypto/Parameters/ClpECDomainParameters.pas

@@ -51,18 +51,19 @@ type
 
   public
 
-    constructor Create(curve: IECCurve; g: IECPoint; n: TBigInteger); overload;
-    constructor Create(curve: IECCurve; g: IECPoint;
-      n, h: TBigInteger); overload;
-    constructor Create(curve: IECCurve; g: IECPoint; n, h: TBigInteger;
-      seed: TCryptoLibByteArray); overload;
+    constructor Create(const curve: IECCurve; const g: IECPoint;
+      const n: 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; seed: TCryptoLibByteArray); overload;
 
     property curve: IECCurve read GetCurve;
     property g: IECPoint read GetG;
     property n: TBigInteger read GetN;
     property h: TBigInteger read GetH;
     property seed: TCryptoLibByteArray read GetSeed;
-    function Equals(other: IECDomainParameters): Boolean; reintroduce;
+    function Equals(const other: IECDomainParameters): Boolean; reintroduce;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -72,20 +73,20 @@ implementation
 
 { TECDomainParameters }
 
-constructor TECDomainParameters.Create(curve: IECCurve; g: IECPoint;
-  n: TBigInteger);
+constructor TECDomainParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n: TBigInteger);
 begin
   Create(curve, g, n, TBigInteger.One)
 end;
 
-constructor TECDomainParameters.Create(curve: IECCurve; g: IECPoint;
-  n, h: TBigInteger);
+constructor TECDomainParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n, h: TBigInteger);
 begin
   Create(curve, g, n, h, Nil);
 end;
 
-constructor TECDomainParameters.Create(curve: IECCurve; g: IECPoint;
-  n, h: TBigInteger; seed: TCryptoLibByteArray);
+constructor TECDomainParameters.Create(const curve: IECCurve; const g: IECPoint;
+  const n, h: TBigInteger; seed: TCryptoLibByteArray);
 begin
   if (curve = Nil) then
     raise EArgumentNilCryptoLibException.CreateRes(@SCurveNil);
@@ -109,7 +110,7 @@ begin
 
 end;
 
-function TECDomainParameters.Equals(other: IECDomainParameters): Boolean;
+function TECDomainParameters.Equals(const other: IECDomainParameters): Boolean;
 begin
 
   if (other = Self as IECDomainParameters) then

CryptoLib/src/Crypto/Parameters/ClpECKeyGenerationParameters.pas

@@ -42,10 +42,10 @@ type
     function GetPublicKeyParamSet: IDerObjectIdentifier;
 
   public
-    constructor Create(domainParameters: IECDomainParameters;
-      random: ISecureRandom); overload;
-    constructor Create(publicKeyParamSet: IDerObjectIdentifier;
-      random: ISecureRandom); overload;
+    constructor Create(const domainParameters: IECDomainParameters;
+      const random: ISecureRandom); overload;
+    constructor Create(const publicKeyParamSet: IDerObjectIdentifier;
+      const random: ISecureRandom); overload;
     property domainParameters: IECDomainParameters read GetDomainParameters;
     property publicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
 
@@ -58,15 +58,15 @@ uses
 
 { TECKeyGenerationParameters }
 
-constructor TECKeyGenerationParameters.Create(domainParameters
-  : IECDomainParameters; random: ISecureRandom);
+constructor TECKeyGenerationParameters.Create(const domainParameters
+  : IECDomainParameters; const random: ISecureRandom);
 begin
   Inherited Create(random, domainParameters.N.BitLength);
   FdomainParams := domainParameters;
 end;
 
-constructor TECKeyGenerationParameters.Create(publicKeyParamSet
-  : IDerObjectIdentifier; random: ISecureRandom);
+constructor TECKeyGenerationParameters.Create(const publicKeyParamSet
+  : IDerObjectIdentifier; const random: ISecureRandom);
 begin
   Create(TECKeyParameters.LookupParameters(publicKeyParamSet), random);
   FpublicKeyParamSet := publicKeyParamSet;

CryptoLib/src/Crypto/Parameters/ClpECKeyParameters.pas

@@ -66,21 +66,21 @@ type
   strict protected
 
     constructor Create(const algorithm: String; isPrivate: Boolean;
-      parameters: IECDomainParameters); overload;
+      const parameters: IECDomainParameters); overload;
 
     constructor Create(const algorithm: String; isPrivate: Boolean;
-      publicKeyParamSet: IDerObjectIdentifier); overload;
+      const publicKeyParamSet: IDerObjectIdentifier); overload;
 
-    function CreateKeyGenerationParameters(random: ISecureRandom)
+    function CreateKeyGenerationParameters(const random: ISecureRandom)
       : IECKeyGenerationParameters; inline;
 
-    function Equals(other: IECKeyParameters): Boolean; reintroduce;
+    function Equals(const other: IECKeyParameters): Boolean; reintroduce;
 
   public
     class function VerifyAlgorithmName(const algorithm: String): String;
       static; inline;
-    class function LookupParameters(publicKeyParamSet: IDerObjectIdentifier)
-      : IECDomainParameters; static;
+    class function LookupParameters(const publicKeyParamSet
+      : IDerObjectIdentifier): IECDomainParameters; static;
     property AlgorithmName: String read GetAlgorithmName;
     property parameters: IECDomainParameters read GetParameters;
     property publicKeyParamSet: IDerObjectIdentifier read GetPublicKeyParamSet;
@@ -96,7 +96,7 @@ uses
 
 { TECKeyParameters }
 
-class function TECKeyParameters.LookupParameters(publicKeyParamSet
+class function TECKeyParameters.LookupParameters(const publicKeyParamSet
   : IDerObjectIdentifier): IECDomainParameters;
 var
   p: IECDomainParameters;
@@ -155,7 +155,7 @@ begin
 end;
 
 constructor TECKeyParameters.Create(const algorithm: String; isPrivate: Boolean;
-  parameters: IECDomainParameters);
+  const parameters: IECDomainParameters);
 begin
   Inherited Create(isPrivate);
   if (algorithm = '') then
@@ -169,7 +169,7 @@ begin
 end;
 
 constructor TECKeyParameters.Create(const algorithm: String; isPrivate: Boolean;
-  publicKeyParamSet: IDerObjectIdentifier);
+  const publicKeyParamSet: IDerObjectIdentifier);
 begin
   Inherited Create(isPrivate);
 
@@ -184,8 +184,8 @@ begin
   FpublicKeyParamSet := publicKeyParamSet;
 end;
 
-function TECKeyParameters.CreateKeyGenerationParameters(random: ISecureRandom)
-  : IECKeyGenerationParameters;
+function TECKeyParameters.CreateKeyGenerationParameters
+  (const random: ISecureRandom): IECKeyGenerationParameters;
 begin
   if (publicKeyParamSet <> Nil) then
   begin
@@ -195,7 +195,7 @@ begin
   result := TECKeyGenerationParameters.Create(parameters, random);
 end;
 
-function TECKeyParameters.Equals(other: IECKeyParameters): Boolean;
+function TECKeyParameters.Equals(const other: IECKeyParameters): Boolean;
 begin
   if (other = Self as IECKeyParameters) then
   begin

CryptoLib/src/Crypto/Parameters/ClpECPrivateKeyParameters.pas

@@ -43,18 +43,18 @@ type
     function GetD: TBigInteger; inline;
 
   public
-    constructor Create(d: TBigInteger;
-      parameters: IECDomainParameters); overload;
+    constructor Create(const d: TBigInteger;
+      const parameters: IECDomainParameters); overload;
 
-    constructor Create(const algorithm: String; d: TBigInteger;
-      parameters: IECDomainParameters); overload;
+    constructor Create(const algorithm: String; const d: TBigInteger;
+      const parameters: IECDomainParameters); overload;
 
-    constructor Create(const algorithm: String; d: TBigInteger;
-      publicKeyParamSet: IDerObjectIdentifier); overload;
+    constructor Create(const algorithm: String; const d: TBigInteger;
+      const publicKeyParamSet: IDerObjectIdentifier); overload;
 
     property d: TBigInteger read GetD;
 
-    function Equals(other: IECPrivateKeyParameters): Boolean; reintroduce;
+    function Equals(const other: IECPrivateKeyParameters): Boolean; reintroduce;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -64,14 +64,14 @@ implementation
 
 { TECPrivateKeyParameters }
 
-constructor TECPrivateKeyParameters.Create(d: TBigInteger;
-  parameters: IECDomainParameters);
+constructor TECPrivateKeyParameters.Create(const d: TBigInteger;
+  const parameters: IECDomainParameters);
 begin
   Create('EC', d, parameters);
 end;
 
 constructor TECPrivateKeyParameters.Create(const algorithm: String;
-  d: TBigInteger; parameters: IECDomainParameters);
+  const d: TBigInteger; const parameters: IECDomainParameters);
 begin
   Inherited Create(algorithm, true, parameters);
   if (not(d.IsInitialized)) then
@@ -81,7 +81,7 @@ begin
 end;
 
 constructor TECPrivateKeyParameters.Create(const algorithm: String;
-  d: TBigInteger; publicKeyParamSet: IDerObjectIdentifier);
+  const d: TBigInteger; const publicKeyParamSet: IDerObjectIdentifier);
 begin
   Inherited Create(algorithm, true, publicKeyParamSet);
   if (not(d.IsInitialized)) then
@@ -90,8 +90,8 @@ begin
   Fd := d;
 end;
 
-function TECPrivateKeyParameters.Equals(other: IECPrivateKeyParameters)
-  : Boolean;
+function TECPrivateKeyParameters.Equals(const other
+  : IECPrivateKeyParameters): Boolean;
 begin
   if (other = Self as IECPrivateKeyParameters) then
   begin

CryptoLib/src/Crypto/Parameters/ClpECPublicKeyParameters.pas

@@ -44,20 +44,21 @@ type
     Fq: IECPoint;
 
     function GetQ: IECPoint; inline;
-    class function Validate(q: IECPoint): IECPoint; static; inline;
+    class function Validate(const q: IECPoint): IECPoint; static; inline;
 
   public
-    constructor Create(q: IECPoint; parameters: IECDomainParameters); overload;
+    constructor Create(const q: IECPoint;
+      const parameters: IECDomainParameters); overload;
 
-    constructor Create(const algorithm: String; q: IECPoint;
-      parameters: IECDomainParameters); overload;
+    constructor Create(const algorithm: String; const q: IECPoint;
+      const parameters: IECDomainParameters); overload;
 
-    constructor Create(const algorithm: String; q: IECPoint;
-      publicKeyParamSet: IDerObjectIdentifier); overload;
+    constructor Create(const algorithm: String; const q: IECPoint;
+      const publicKeyParamSet: IDerObjectIdentifier); overload;
 
     property q: IECPoint read GetQ;
 
-    function Equals(other: IECPublicKeyParameters): Boolean; reintroduce;
+    function Equals(const other: IECPublicKeyParameters): Boolean; reintroduce;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}override;
 
@@ -67,7 +68,7 @@ implementation
 
 { TECPublicKeyParameters }
 
-class function TECPublicKeyParameters.Validate(q: IECPoint): IECPoint;
+class function TECPublicKeyParameters.Validate(const q: IECPoint): IECPoint;
 begin
   if (q = Nil) then
     raise EArgumentNilCryptoLibException.CreateRes(@SQNil);
@@ -75,16 +76,15 @@ begin
   if (q.IsInfinity) then
     raise EArgumentCryptoLibException.CreateRes(@SQInfinity);
 
-  q := q.Normalize();
+  result := q.Normalize();
 
-  if (not(q.IsValid())) then
+  if (not(result.IsValid())) then
     raise EArgumentCryptoLibException.CreateRes(@SQPointNotOnCurve);
 
-  result := q;
 end;
 
-constructor TECPublicKeyParameters.Create(const algorithm: String; q: IECPoint;
-  parameters: IECDomainParameters);
+constructor TECPublicKeyParameters.Create(const algorithm: String;
+  const q: IECPoint; const parameters: IECDomainParameters);
 begin
   Inherited Create(algorithm, false, parameters);
   if (q = Nil) then
@@ -93,14 +93,14 @@ begin
   Fq := Validate(q);
 end;
 
-constructor TECPublicKeyParameters.Create(q: IECPoint;
-  parameters: IECDomainParameters);
+constructor TECPublicKeyParameters.Create(const q: IECPoint;
+  const parameters: IECDomainParameters);
 begin
   Create('EC', q, parameters);
 end;
 
-constructor TECPublicKeyParameters.Create(const algorithm: String; q: IECPoint;
-  publicKeyParamSet: IDerObjectIdentifier);
+constructor TECPublicKeyParameters.Create(const algorithm: String;
+  const q: IECPoint; const publicKeyParamSet: IDerObjectIdentifier);
 begin
   Inherited Create(algorithm, false, publicKeyParamSet);
   if (q = Nil) then
@@ -109,7 +109,8 @@ begin
   Fq := Validate(q);
 end;
 
-function TECPublicKeyParameters.Equals(other: IECPublicKeyParameters): Boolean;
+function TECPublicKeyParameters.Equals(const other
+  : IECPublicKeyParameters): Boolean;
 begin
   if (other = Self as IECPublicKeyParameters) then
   begin

CryptoLib/src/Crypto/Parameters/ClpParametersWithRandom.pas

@@ -45,10 +45,10 @@ type
 
   public
 
-    constructor Create(parameters: ICipherParameters); overload;
+    constructor Create(const parameters: ICipherParameters); overload;
 
-    constructor Create(parameters: ICipherParameters;
-      random: ISecureRandom); overload;
+    constructor Create(const parameters: ICipherParameters;
+      const random: ISecureRandom); overload;
 
     property random: ISecureRandom read GetRandom;
 
@@ -60,13 +60,13 @@ implementation
 
 { TParametersWithRandom }
 
-constructor TParametersWithRandom.Create(parameters: ICipherParameters);
+constructor TParametersWithRandom.Create(const parameters: ICipherParameters);
 begin
-  Create(parameters, TSecureRandom.Create());
+  Create(parameters, TSecureRandom.Create() as ISecureRandom);
 end;
 
-constructor TParametersWithRandom.Create(parameters: ICipherParameters;
-  random: ISecureRandom);
+constructor TParametersWithRandom.Create(const parameters: ICipherParameters;
+  const random: ISecureRandom);
 begin
   inherited Create();
   if (parameters = Nil) then

CryptoLib/src/Crypto/Prng/ClpCryptoApiRandomGenerator.pas

@@ -47,7 +47,7 @@ type
     /// Uses TRandomNumberGenerator.CreateRNG() to Get randomness generator
     /// </summary>
     constructor Create(); overload;
-    constructor Create(rng: IRandomNumberGenerator); overload;
+    constructor Create(const rng: IRandomNumberGenerator); overload;
 
     /// <summary>Add more seed material to the generator.</summary>
     /// <param name="seed">A byte array to be mixed into the generator's state.</param>
@@ -84,8 +84,9 @@ begin
   // We don't care about the seed
 end;
 
-constructor TCryptoApiRandomGenerator.Create(rng: IRandomNumberGenerator);
+constructor TCryptoApiRandomGenerator.Create(const rng: IRandomNumberGenerator);
 begin
+  Inherited Create();
   FrndProv := rng;
 end;
 

CryptoLib/src/Crypto/Prng/ClpDigestRandomGenerator.pas

@@ -64,7 +64,7 @@ type
 
   public
 
-    constructor Create(digest: IHash);
+    constructor Create(const digest: IHash);
     procedure AddSeedMaterial(inSeed: TCryptoLibByteArray); overload; inline;
     procedure AddSeedMaterial(rSeed: Int64); overload; inline;
     procedure NextBytes(bytes: TCryptoLibByteArray); overload; inline;
@@ -124,7 +124,7 @@ begin
   end;
 end;
 
-constructor TDigestRandomGenerator.Create(digest: IHash);
+constructor TDigestRandomGenerator.Create(const digest: IHash);
 begin
   Inherited Create();
   Fdigest := digest;

CryptoLib/src/Crypto/Signers/ClpDsaDigestSigner.pas

@@ -39,18 +39,19 @@ type
     FdsaSigner: IDsa;
     FforSigning: Boolean;
 
-    function DerEncode(r, s: TBigInteger): TCryptoLibByteArray; inline;
+    function DerEncode(const r, s: TBigInteger): TCryptoLibByteArray; inline;
 
     function DerDecode(encoding: TCryptoLibByteArray)
       : TCryptoLibGenericArray<TBigInteger>; inline;
 
   public
-    constructor Create(signer: IDsa; digest: IHash);
+    constructor Create(const signer: IDsa; const digest: IHash);
 
     function GetAlgorithmName: String; virtual;
     property AlgorithmName: String read GetAlgorithmName;
 
-    procedure Init(forSigning: Boolean; parameters: ICipherParameters); virtual;
+    procedure Init(forSigning: Boolean;
+      const parameters: ICipherParameters); virtual;
 
     /// <summary>
     /// update the internal digest with the byte b
@@ -92,7 +93,7 @@ begin
   Fdigest.TransformBytes(input, inOff, length);
 end;
 
-constructor TDsaDigestSigner.Create(signer: IDsa; digest: IHash);
+constructor TDsaDigestSigner.Create(const signer: IDsa; const digest: IHash);
 begin
   FdsaSigner := signer;
   Fdigest := digest;
@@ -108,10 +109,11 @@ begin
     ((s[0] as IDerInteger).Value, (s[1] as IDerInteger).Value);
 end;
 
-function TDsaDigestSigner.DerEncode(r, s: TBigInteger): TCryptoLibByteArray;
+function TDsaDigestSigner.DerEncode(const r, s: TBigInteger)
+  : TCryptoLibByteArray;
 begin
-  Result := TDerSequence.Create([TDerInteger.Create(r), TDerInteger.Create(s)])
-    .GetDerEncoded();
+  Result := TDerSequence.Create([TDerInteger.Create(r) as IDerInteger,
+    TDerInteger.Create(s) as IDerInteger]).GetDerEncoded();
 end;
 
 function TDsaDigestSigner.GenerateSignature: TCryptoLibByteArray;
@@ -140,7 +142,7 @@ begin
 end;
 
 procedure TDsaDigestSigner.Init(forSigning: Boolean;
-  parameters: ICipherParameters);
+  const parameters: ICipherParameters);
 var
   k: IAsymmetricKeyParameter;
   withRandom: IParametersWithRandom;

CryptoLib/src/Crypto/Signers/ClpECDsaSigner.pas

@@ -1,3 +1,20 @@
+{ *********************************************************************************** }
+{ *                              CryptoLib Library                                  * }
+{ *                    Copyright (c) 2018 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://sphere10.com) for sponsoring        * }
+{ *                        the development of this library                          * }
+
+{ * ******************************************************************************* * }
+
+(* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& *)
+
 unit ClpECDsaSigner;
 
 {$I ..\..\Include\CryptoLib.inc}
@@ -53,15 +70,15 @@ type
     Fkey: IECKeyParameters;
     Frandom: ISecureRandom;
 
-    function CalculateE(n: TBigInteger; &message: TCryptoLibByteArray)
+    function CalculateE(const n: TBigInteger; &message: TCryptoLibByteArray)
       : TBigInteger; virtual;
 
     function CreateBasePointMultiplier(): IECMultiplier; virtual;
 
-    function GetDenominator(coordinateSystem: Int32; p: IECPoint)
+    function GetDenominator(coordinateSystem: Int32; const p: IECPoint)
       : IECFieldElement; virtual;
 
-    function InitSecureRandom(needed: Boolean; provided: ISecureRandom)
+    function InitSecureRandom(needed: Boolean; const provided: ISecureRandom)
       : ISecureRandom; virtual;
 
   public
@@ -78,7 +95,7 @@ type
     /// <param name="kCalculator">
     /// kCalculator a K value calculator.
     /// </param>
-    constructor Create(kCalculator: IDsaKCalculator); overload;
+    constructor Create(const kCalculator: IDsaKCalculator); overload;
 
     function GetAlgorithmName: String; virtual;
     property AlgorithmName: String read GetAlgorithmName;
@@ -101,8 +118,8 @@ type
     // * the passed in message (for standard DSA the message should be
     // * a SHA-1 hash of the real message to be verified).
     // */
-    function VerifySignature(&message: TCryptoLibByteArray;
-      r, s: TBigInteger): Boolean;
+    function VerifySignature(&message: TCryptoLibByteArray; r: TBigInteger;
+      const s: TBigInteger): Boolean;
 
   end;
 
@@ -115,8 +132,8 @@ begin
   FkCalculator := TRandomDsaKCalculator.Create();
 end;
 
-function TECDsaSigner.CalculateE(n: TBigInteger; &message: TCryptoLibByteArray)
-  : TBigInteger;
+function TECDsaSigner.CalculateE(const n: TBigInteger;
+  &message: TCryptoLibByteArray): TBigInteger;
 var
   messageBitLength: Int32;
   trunc: TBigInteger;
@@ -132,7 +149,7 @@ begin
   Result := trunc;
 end;
 
-constructor TECDsaSigner.Create(kCalculator: IDsaKCalculator);
+constructor TECDsaSigner.Create(const kCalculator: IDsaKCalculator);
 begin
   inherited Create();
   FkCalculator := kCalculator;
@@ -197,7 +214,7 @@ begin
   Result := 'ECDSA';
 end;
 
-function TECDsaSigner.GetDenominator(coordinateSystem: Int32; p: IECPoint)
+function TECDsaSigner.GetDenominator(coordinateSystem: Int32; const p: IECPoint)
   : IECFieldElement;
 begin
   case (coordinateSystem) of
@@ -261,8 +278,8 @@ begin
     (not FkCalculator.IsDeterministic), providedRandom);
 end;
 
-function TECDsaSigner.InitSecureRandom(needed: Boolean; provided: ISecureRandom)
-  : ISecureRandom;
+function TECDsaSigner.InitSecureRandom(needed: Boolean;
+  const provided: ISecureRandom): ISecureRandom;
 begin
   if (not needed) then
   begin
@@ -282,7 +299,7 @@ begin
 end;
 
 function TECDsaSigner.VerifySignature(&message: TCryptoLibByteArray;
-  r, s: TBigInteger): Boolean;
+  r: TBigInteger; const s: TBigInteger): Boolean;
 var
   n, e, c, u1, u2, cofactor, v: TBigInteger;
   G, Q, point: IECPoint;

CryptoLib/src/Crypto/Signers/ClpRandomDsaKCalculator.pas

@@ -29,7 +29,8 @@ type
 
   public
     property IsDeterministic: Boolean read GetIsDeterministic;
-    procedure Init(n: TBigInteger; random: ISecureRandom); overload; virtual;
+    procedure Init(const n: TBigInteger; const random: ISecureRandom);
+      overload; virtual;
     procedure Init(n, d: TBigInteger; &message: TCryptoLibByteArray);
       overload; virtual;
     function NextK(): TBigInteger; virtual;
@@ -44,7 +45,8 @@ begin
   Result := False;
 end;
 
-procedure TRandomDsaKCalculator.Init(n: TBigInteger; random: ISecureRandom);
+procedure TRandomDsaKCalculator.Init(const n: TBigInteger;
+  const random: ISecureRandom);
 begin
   Fq := n;
   Frandom := random;

CryptoLib/src/Interfaces/ClpIAbstractECMultiplier.pas

@@ -30,9 +30,10 @@ type
   IAbstractECMultiplier = interface(IECMultiplier)
     ['{DD63984C-7D4D-46DE-9004-20FD909C2EFB}']
 
-    function MultiplyPositive(p: IECPoint; k: TBigInteger): IECPoint;
+    function MultiplyPositive(const p: IECPoint; const k: TBigInteger)
+      : IECPoint;
 
-    function Multiply(p: IECPoint; k: TBigInteger): IECPoint;
+    function Multiply(const p: IECPoint; const k: TBigInteger): IECPoint;
 
   end;
 

CryptoLib/src/Interfaces/ClpIAsn1OctetString.pas

@@ -35,7 +35,7 @@ type
     function GetParser: IAsn1OctetStringParser;
 
     function Asn1GetHashCode(): Int32;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 
     property Str: TCryptoLibByteArray read GetStr;
     property Parser: IAsn1OctetStringParser read GetParser;

CryptoLib/src/Interfaces/ClpIAsn1Sequence.pas

@@ -37,8 +37,8 @@ type
     function GetCurrent(e: TEnumerator<IAsn1Encodable>): IAsn1Encodable;
 
     function Asn1GetHashCode(): Int32;
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean;
-    procedure AddObject(obj: IAsn1Encodable);
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean;
+    procedure AddObject(const obj: IAsn1Encodable);
 
     function ToString(): String;
 

CryptoLib/src/Interfaces/ClpIAsn1TaggedObject.pas

@@ -32,7 +32,7 @@ type
     function Getexplicitly: Boolean;
     function Getobj: IAsn1Encodable;
 
-    function Asn1Equals(asn1Object: IAsn1Object): Boolean;
+    function Asn1Equals(const asn1Object: IAsn1Object): Boolean;
 
     function Asn1GetHashCode(): Int32;
 

CryptoLib/src/Interfaces/ClpIAsymmetricCipherKeyPairGenerator.pas

@@ -34,7 +34,7 @@ type
     // *
     // * @param the parameters the key pair is to be initialised with.
     // */
-    procedure Init(parameters: IKeyGenerationParameters);
+    procedure Init(const parameters: IKeyGenerationParameters);
 
     // /**
     // * return an AsymmetricCipherKeyPair containing the Generated keys.

CryptoLib/src/Interfaces/ClpIAsymmetricKeyParameter.pas

@@ -33,7 +33,7 @@ type
     function GetPrivateKey: Boolean;
     property IsPrivate: Boolean read GetIsPrivate;
     property PrivateKey: Boolean read GetPrivateKey;
-    function Equals(other: IAsymmetricKeyParameter): Boolean;
+    function Equals(const other: IAsymmetricKeyParameter): Boolean;
     function GetHashCode(): {$IFDEF DELPHI}Int32; {$ELSE}PtrInt;
 {$ENDIF DELPHI}
   end;

CryptoLib/src/Interfaces/ClpIBerBitString.pas

@@ -30,7 +30,7 @@ type
 
     ['{6AB7DC7E-CD61-4D34-AE15-99E036688C77}']
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
 
   end;
 

CryptoLib/src/Interfaces/ClpIBerGenerator.pas

@@ -36,7 +36,7 @@ type
     procedure WriteBerBody(contentStream: TStream);
     procedure WriteBerEnd();
 
-    procedure AddObject(obj: IAsn1Encodable);
+    procedure AddObject(const obj: IAsn1Encodable);
     function GetRawOutputStream(): TStream;
     procedure Close();
 

CryptoLib/src/Interfaces/ClpIBerNull.pas

@@ -29,7 +29,7 @@ type
   IBerNull = interface(IDerNull)
     ['{16AF74E8-26E1-466D-BE93-38A06853DA98}']
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
   end;
 
 implementation

CryptoLib/src/Interfaces/ClpIBerOctetString.pas

@@ -42,7 +42,7 @@ type
 
     function GetEnumerator: TEnumerator<IDerOctetString>;
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
 
   end;
 

CryptoLib/src/Interfaces/ClpIBerSequence.pas

@@ -30,7 +30,7 @@ type
 
     ['{B78E91BF-DB39-4033-8A7A-F0D024C5322A}']
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
 
   end;
 

CryptoLib/src/Interfaces/ClpIBerSet.pas

@@ -29,7 +29,7 @@ type
   IBerSet = interface(IDerSet)
     ['{FD8838BB-8905-409A-AB93-136EEC6A05E4}']
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
 
   end;
 

CryptoLib/src/Interfaces/ClpIBerTaggedObject.pas

@@ -30,7 +30,7 @@ type
 
     ['{DD6A102D-70DC-4428-8199-62D88276BDBA}']
 
-    procedure Encode(derOut: IDerOutputStream);
+    procedure Encode(const derOut: IDerOutputStream);
   end;
 
 implementation