657 lines
25 KiB
ObjectPascal
657 lines
25 KiB
ObjectPascal
{*****************************************************************************
|
|
The DEC team (see file NOTICE.txt) licenses this file
|
|
to you under the Apache License, Version 2.0 (the
|
|
"License"); you may not use this file except in compliance
|
|
with the License. A copy of this licence is found in the root directory of
|
|
this project in the file LICENCE.txt or alternatively at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing,
|
|
software distributed under the License is distributed on an
|
|
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, either express or implied. See the License for the
|
|
specific language governing permissions and limitations
|
|
under the License.
|
|
*****************************************************************************}
|
|
|
|
{$M+} // DUnitX would add it anyway
|
|
unit TestDECHashKDF;
|
|
|
|
interface
|
|
|
|
// Needs to be included before any other statements
|
|
{$INCLUDE TestDefines.inc}
|
|
{$INCLUDE ..\..\Source\DECOptions.inc}
|
|
|
|
uses
|
|
System.Classes, System.SysUtils, Generics.Collections,
|
|
{$IFDEF DUnitX}
|
|
DUnitX.TestFramework,DUnitX.DUnitCompatibility,
|
|
{$ELSE}
|
|
TestFramework,
|
|
{$ENDIF}
|
|
TestDECTestDataContainer, DECTypes, DECBaseClass, DECHash, DECHashBase,
|
|
DECHashAuthentication, DECUtil, DECFormatBase;
|
|
|
|
type
|
|
/// <summary>
|
|
/// Meta class to store class references in the list as there is no pointer
|
|
/// to class methods as it seems
|
|
/// </summary>
|
|
THashClass = class of TDECHash;
|
|
|
|
/// <summary>
|
|
/// Type of the KDF or MGF variant to be tested
|
|
/// </summary>
|
|
TKDFMGFAlgorithm = (ktKDF1, ktKDF2, ktKDF3, ktKDFx, ktMGF1, ktMGFx);
|
|
|
|
/// <summary>
|
|
/// Record containing everything necessary for a single key deviation
|
|
/// method test
|
|
/// </summary>
|
|
TKeyDeviationTestData = record
|
|
/// <summary>
|
|
/// Test data as normal text
|
|
/// </summary>
|
|
InputData : RawByteString;
|
|
/// <summary>
|
|
/// Optional parameter for some key deviation tests.
|
|
/// </summary>
|
|
SeedData : RawByteString;
|
|
/// <summary>
|
|
/// Test output in hexadecimal format
|
|
/// </summary>
|
|
OutputData : RawByteString;
|
|
/// <summary>
|
|
/// Requested output length
|
|
/// </summary>
|
|
MaskSize : Integer;
|
|
/// <summary>
|
|
/// If the entry is for a KDF1-KDF3 or KDFx test define which test method to call
|
|
/// </summary>
|
|
Algorithm : TKDFMGFAlgorithm;
|
|
/// <summary>
|
|
/// Class reference containing the class methods to be tested
|
|
/// </summary>
|
|
HashClass : TDECHashAuthenticationClass;
|
|
/// <summary>
|
|
/// Index, which i being used for the KDFx and MGFx variants of the
|
|
/// original author of DEC
|
|
/// </summary>
|
|
Index : UInt32;
|
|
end;
|
|
|
|
/// <summary>
|
|
/// List of all the test cases
|
|
/// </summary>
|
|
TKeyDeviationTestList = class(TList<TKeyDeviationTestData>)
|
|
public
|
|
/// <summary>
|
|
/// Add one entry to the list
|
|
/// </summary>
|
|
/// <param name="InputData">
|
|
/// Test data as normal text
|
|
/// </param>
|
|
/// <param name="OutputData">
|
|
/// Test output in hexadecimal format
|
|
/// </param>
|
|
/// <param name="MaskSize">
|
|
/// Requested output length
|
|
/// </param>
|
|
/// <param name="HashClass">
|
|
/// Class reference containing the class methods to be tested
|
|
/// </param>
|
|
/// <param name="AlgorithmType">
|
|
/// Algorithm for which the test data specified is
|
|
/// </param>
|
|
/// <param name="Index">
|
|
/// Index, which i being used for the KDFx and MGFx variants of the
|
|
/// original author of DEC
|
|
/// </param>
|
|
procedure Add(const InputData, OutputData: RawByteString;
|
|
MaskSize : Integer; HashClass: TDECHashAuthenticationClass;
|
|
AlgorithmType : TKDFMGFAlgorithm = ktKDF1;
|
|
Index : UInt32 = 1); overload;
|
|
/// <summary>
|
|
/// Add one entry to the list
|
|
/// </summary>
|
|
/// <param name="InputData">
|
|
/// Test data as normal text
|
|
/// </param>
|
|
/// <param name="SeedData">
|
|
/// Optional parameter for some tests. Given in hexadecimal format.
|
|
/// </param>
|
|
/// <param name="OutputData">
|
|
/// Test output in hexadecimal format
|
|
/// </param>
|
|
/// <param name="MaskSize">
|
|
/// Requested output length
|
|
/// </param>
|
|
/// <param name="HashClass">
|
|
/// Class reference containing the class methods to be tested
|
|
/// </param>
|
|
/// <param name="AlgorithmType">
|
|
/// Algorithm for which the test data specified is
|
|
/// </param>
|
|
/// <param name="Index">
|
|
/// Index, which i being used for the KDFx and MGFx variants of the
|
|
/// original author of DEC
|
|
/// </param>
|
|
procedure Add(const InputData, SeedData, OutputData: RawByteString;
|
|
MaskSize : Integer; HashClass: TDECHashAuthenticationClass;
|
|
AlgorithmType : TKDFMGFAlgorithm = ktKDF1;
|
|
Index : UInt32 = 1); overload;
|
|
end;
|
|
|
|
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
|
/// <summary>
|
|
/// All test cases for the MGF1 class methods. These are in this class rather
|
|
/// than in TestTDECHash as the MGF1 class methods can only be called on a
|
|
/// concrete hash class as they use the DigestSize and would otherwise fail.
|
|
/// We currently mostly have test data for the SHA1 (= SHA with 128 bit length)
|
|
/// algorithm, but the MGF1 method is universally useable so the tests got
|
|
/// separated here.
|
|
/// </summary>
|
|
TestTHash_MGF1 = class(TTestCase)
|
|
strict protected
|
|
// List of test cases, defined in such a way that input, length,
|
|
// output and hash class to be used shall be spoecified.
|
|
FTestData : TKeyDeviationTestList;
|
|
public
|
|
procedure SetUp; override;
|
|
procedure TearDown; override;
|
|
|
|
procedure TestTBytesInternal(Algorithm : TKDFMGFAlgorithm);
|
|
procedure TestRawMemoryInternal(Algorithm : TKDFMGFAlgorithm);
|
|
published
|
|
procedure TestMGF1TBytes;
|
|
procedure TestMGF1RawMemory;
|
|
procedure TestMGFxTBytes;
|
|
procedure TestMGFxRawMemory;
|
|
end;
|
|
|
|
{$IFDEF DUnitX} [TestFixture] {$ENDIF}
|
|
/// <summary>
|
|
/// All test cases for the KDF class methods. These are in this class rather
|
|
/// than in TestTDECHash as the KDF class methods can only be called on a
|
|
/// concrete hash class as they use the DigestSize and would otherwise fail.
|
|
/// We currently mostly have test data for the SHA and SHA256 algorithms,
|
|
/// but the MGF1 method is universally useable so the tests got separated here.
|
|
/// </summary>
|
|
TestTHash_KDF = class(TTestCase)
|
|
strict protected
|
|
// List of test cases, defined in such a way that input, length,
|
|
// output and hash class to be used shall be spoecified.
|
|
FTestData : TKeyDeviationTestList;
|
|
|
|
procedure InternalTest(KDFType: TKDFMGFAlgorithm);
|
|
procedure InternalTestTBytes(KDFType: TKDFMGFAlgorithm);
|
|
public
|
|
procedure SetUp; override;
|
|
procedure TearDown; override;
|
|
published
|
|
procedure TestKDF1;
|
|
procedure TestKDF1TBytes;
|
|
procedure TestKDF2;
|
|
procedure TestKDF2TBytes;
|
|
procedure TestKDF3;
|
|
procedure TestKDF3TBytes;
|
|
procedure TestKDFx;
|
|
procedure TestKDFxTBytes;
|
|
end;
|
|
|
|
implementation
|
|
|
|
uses
|
|
DECFormat;
|
|
|
|
{ TKeyDeviationTestList }
|
|
|
|
procedure TKeyDeviationTestList.Add(const InputData, OutputData: RawByteString;
|
|
MaskSize: Integer; HashClass: TDECHashAuthenticationClass;
|
|
AlgorithmType : TKDFMGFAlgorithm = ktKDF1;
|
|
Index : UInt32 = 1);
|
|
var
|
|
Data: TKeyDeviationTestData;
|
|
begin
|
|
Data.InputData := InputData;
|
|
Data.OutputData := OutputData;
|
|
Data.MaskSize := MaskSize;
|
|
Data.HashClass := HashClass;
|
|
Data.Algorithm := AlgorithmType;
|
|
Data.Index := Index;
|
|
|
|
self.Add(Data);
|
|
end;
|
|
|
|
procedure TKeyDeviationTestList.Add(const InputData, SeedData,
|
|
OutputData: RawByteString; MaskSize: Integer; HashClass: TDECHashAuthenticationClass;
|
|
AlgorithmType : TKDFMGFAlgorithm = ktKDF1;
|
|
Index : UInt32 = 1);
|
|
var
|
|
Data: TKeyDeviationTestData;
|
|
begin
|
|
Data.InputData := InputData;
|
|
Data.SeedData := SeedData; //SysUtils.BytesOf(TFormat_HexL.Decode(SeedData));
|
|
Data.OutputData := OutputData;
|
|
Data.MaskSize := MaskSize;
|
|
Data.HashClass := HashClass;
|
|
Data.Algorithm := AlgorithmType;
|
|
Data.Index := Index;
|
|
|
|
self.Add(Data);
|
|
end;
|
|
|
|
{ TestTHash_KDF }
|
|
|
|
procedure TestTHash_KDF.InternalTest(KDFType: TKDFMGFAlgorithm);
|
|
var
|
|
TestData : TKeyDeviationTestData;
|
|
Result, ExpResult, Data, Seed : TBytes;
|
|
begin
|
|
for TestData in FTestData do
|
|
begin
|
|
if (TestData.Algorithm = KDFType) then
|
|
begin
|
|
Data := System.SysUtils.BytesOf(TestData.InputData);
|
|
Seed := System.SysUtils.BytesOf(TestData.SeedData);
|
|
ExpResult := System.SysUtils.BytesOf(TestData.OutputData);
|
|
|
|
case KDFType of
|
|
ktKDF1 : if (length(Seed) = 0) then
|
|
Result := TestData.HashClass.KDF1(Data[0], length(Data),
|
|
NullStr, 0, TestData.MaskSize)
|
|
else
|
|
Result := TestData.HashClass.KDF1(Data[0], length(Data),
|
|
Seed[0], length(Seed), TestData.MaskSize);
|
|
ktKDF2 : if (length(Seed) = 0) then
|
|
Result := TestData.HashClass.KDF2(Data[0], length(Data),
|
|
NullStr, 0, TestData.MaskSize)
|
|
else
|
|
Result := TestData.HashClass.KDF2(Data[0], length(Data),
|
|
Seed[0], length(Seed), TestData.MaskSize);
|
|
ktKDF3 : if (length(Seed) = 0) then
|
|
Result := TestData.HashClass.KDF3(Data[0], length(Data),
|
|
NullStr, 0, TestData.MaskSize)
|
|
else
|
|
Result := TestData.HashClass.KDF3(Data[0], length(Data),
|
|
Seed[0], length(Seed), TestData.MaskSize);
|
|
|
|
ktKDFx : if (length(Seed) = 0) then
|
|
Result := TestData.HashClass.KDFx(Data[0], length(Data),
|
|
NullStr, 0,
|
|
TestData.MaskSize,
|
|
TestData.Index)
|
|
else
|
|
Result := TestData.HashClass.KDFx(Data[0], length(Data),
|
|
Seed[0], length(Seed),
|
|
TestData.MaskSize,
|
|
TestData.Index);
|
|
end;
|
|
|
|
CheckEquals(DECUtil.BytesToRawString(ExpResult),
|
|
DECUtil.BytesToRawString(Result));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TestTHash_KDF.InternalTestTBytes(KDFType: TKDFMGFAlgorithm);
|
|
var
|
|
TestData : TKeyDeviationTestData;
|
|
Result, ExpResult, Data, Seed : TBytes;
|
|
begin
|
|
for TestData in FTestData do
|
|
begin
|
|
if (TestData.Algorithm = KDFType) then
|
|
begin
|
|
Data := System.SysUtils.BytesOf(TestData.InputData);
|
|
Seed := System.SysUtils.BytesOf(TestData.SeedData);
|
|
ExpResult := System.SysUtils.BytesOf(TestData.OutputData);
|
|
|
|
if (KDFType = ktKDF1) then
|
|
Result := TestData.HashClass.KDF1(Data, Seed, TestData.MaskSize);
|
|
|
|
if (KDFType = ktKDF2) then
|
|
Result := TestData.HashClass.KDF2(Data, Seed, TestData.MaskSize);
|
|
|
|
if (KDFType = ktKDF3) then
|
|
Result := TestData.HashClass.KDF3(Data, Seed, TestData.MaskSize);
|
|
|
|
if (KDFType = ktKDFx) then
|
|
Result := TestData.HashClass.KDFx(Data, Seed, TestData.MaskSize, TestData.Index);
|
|
|
|
CheckEquals(DECUtil.BytesToRawString(ExpResult),
|
|
DECUtil.BytesToRawString(Result));
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TestTHash_KDF.SetUp;
|
|
begin
|
|
inherited;
|
|
|
|
FTestData := TKeyDeviationTestList.Create;
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('0001020304'),
|
|
TFormat_HexL.Decode('0506070809'),
|
|
TFormat_HexL.Decode('f52b'),
|
|
2, THash_MD2, ktKDF1);
|
|
|
|
// Test data from Wolfgang Erhard's library
|
|
FTestData.Add(TFormat_HexL.Decode('deadbeeffeebdaed'),
|
|
'',
|
|
TFormat_HexL.Decode('b0ad565b14b478cad4763856ff3016b1' +
|
|
'a93d840f87261bede7ddf0f9305a6e44'),
|
|
32, THash_SHA1, ktKDF1);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('deadbeeffeebdaed'),
|
|
'',
|
|
TFormat_HexL.Decode('87261bede7ddf0f9305a6e44a74e6a08' +
|
|
'46dede27f48205c6b141888742b0ce2c'),
|
|
32, THash_SHA1, ktKDF2);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('deadbeeffeebdaed'),
|
|
'',
|
|
TFormat_HexL.Decode('60cef67059af33f6aebce1e10188f434' +
|
|
'f80306ac0360470aeb41f81bafb35790'),
|
|
32, THash_SHA1, ktKDF3);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('032e45326fa859a72ec235acff929b15' +
|
|
'd1372e30b207255f0611b8f785d76437' +
|
|
'4152e0ac009e509e7ba30cd2f1778e11' +
|
|
'3b64e135cf4e2292c75efe5288edfda4'),
|
|
'',
|
|
TFormat_HexL.Decode('10a2403db42a8743cb989de86e668d16' +
|
|
'8cbe6046e23ff26f741e87949a3bba13' +
|
|
'11ac179f819a3d18412e9eb45668f292' +
|
|
'3c087c1299005f8d5fd42ca257bc93e8' +
|
|
'fee0c5a0d2a8aa70185401fbbd99379e' +
|
|
'c76c663e9a29d0b70f3fe261a59cdc24' +
|
|
'875a60b4aacb1319fa11c3365a8b79a4' +
|
|
'4669f26fba933d012db213d7e3b16349'),
|
|
128, THash_SHA256, ktKDF2);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('032e45326fa859a72ec235acff929b15' +
|
|
'd1372e30b207255f0611b8f785d76437' +
|
|
'4152e0ac009e509e7ba30cd2f1778e11' +
|
|
'3b64e135cf4e2292c75efe5288edfda4'),
|
|
'',
|
|
TFormat_HexL.Decode('0e6a26eb7b956ccb8b3bdc1ca975bc57' +
|
|
'c3989e8fbad31a224655d800c4695484' +
|
|
'0ff32052cdf0d640562bdfadfa263cfc' +
|
|
'cf3c52b29f2af4a1869959bc77f854cf' +
|
|
'15bd7a25192985a842dbff8e13efee5b' +
|
|
'7e7e55bbe4d389647c686a9a9ab3fb88' +
|
|
'9b2d7767d3837eea4e0a2f04b53ca8f5' +
|
|
'0fb31225c1be2d0126c8c7a4753b0807'),
|
|
128, THash_SHA1, ktKDF2);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('ca7c0f8c3ffa87a96e1b74ac8e6af594' +
|
|
'347bb40a'),
|
|
'',
|
|
TFormat_HexL.Decode('744ab703f5bc082e59185f6d049d2d36' +
|
|
'7db245c2'),
|
|
20, THash_SHA1, ktKDF2);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('0499b502fc8b5bafb0f4047e731d1f9f' +
|
|
'd8cd0d8881'),
|
|
'',
|
|
TFormat_HexL.Decode('03c62280c894e103c680b13cd4b4ae74' +
|
|
'0a5ef0c72547292f82dc6b1777f47d63' +
|
|
'ba9d1ea732dbf386'),
|
|
40, THash_SHA1, ktKDF2);
|
|
|
|
// Test vector #1, ANSI X9.63
|
|
FTestData.Add(TFormat_HexL.Decode('96c05619d56c328ab95fe84b18264b08' +
|
|
'725b85e33fd34f08'),
|
|
'',
|
|
TFormat_HexL.Decode('443024c3dae66b95e6f5670601558f71'),
|
|
16, THash_SHA256, ktKDF2);
|
|
|
|
// Test vector #2, ANSI X9.63
|
|
FTestData.Add(TFormat_HexL.Decode('96f600b73ad6ac5629577eced51743dd' +
|
|
'2c24c21b1ac83ee4'),
|
|
'',
|
|
TFormat_HexL.Decode('b6295162a7804f5667ba9070f82fa522'),
|
|
16, THash_SHA256, ktKDF2);
|
|
|
|
// Test vector #3, ANSI X9.63
|
|
FTestData.Add(TFormat_HexL.Decode('22518b10e70f2a3f243810ae3254139e' +
|
|
'fbee04aa57c7af7d'),
|
|
TFormat_HexL.Decode('75eef81aa3041e33b80971203d2c0c52'),
|
|
TFormat_HexL.Decode('c498af77161cc59f2962b9a713e2b215' +
|
|
'152d139766ce34a776df11866a69bf2e' +
|
|
'52a13d9c7c6fc878c50c5ea0bc7b00e0' +
|
|
'da2447cfd874f6cf92f30d0097111485' +
|
|
'500c90c3af8b487872d04685d14c8d1d' +
|
|
'c8d7fa08beb0ce0ababc11f0bd496269' +
|
|
'142d43525a78e5bc79a17f59676a5706' +
|
|
'dc54d54d4d1f0bd7e386128ec26afc21'),
|
|
128, THash_SHA256, ktKDF2);
|
|
|
|
// Test vector #4, ANSI X9.63
|
|
FTestData.Add(TFormat_HexL.Decode('7e335afa4b31d772c0635c7b0e06f26f' +
|
|
'cd781df947d2990a'),
|
|
TFormat_HexL.Decode('d65a4812733f8cdbcdfb4b2f4c191d87'),
|
|
TFormat_HexL.Decode('c0bd9e38a8f9de14c2acd35b2f3410c6' +
|
|
'988cf02400543631e0d6a4c1d030365a' +
|
|
'cbf398115e51aaddebdc9590664210f9' +
|
|
'aa9fed770d4c57edeafa0b8c14f93300' +
|
|
'865251218c262d63dadc47dfa0e02848' +
|
|
'26793985137e0a544ec80abf2fdf5ab9' +
|
|
'0bdaea66204012efe34971dc431d625c' +
|
|
'd9a329b8217cc8fd0d9f02b13f2f6b0b'),
|
|
128, THash_SHA256, ktKDF2);
|
|
|
|
// Test for DEC's own KDFx variant, testdata synthesised and verified against
|
|
// DEC V5.2
|
|
FTestData.Add(TFormat_HexL.Decode('deadbeeffeebdaed'),
|
|
'',
|
|
TFormat_HexL.Decode('e473e6b6065219bab4fde9113bd80301'+
|
|
'6cc49979783559585b0c8bb5bbdfa4cd'),
|
|
32, THash_SHA1, ktKDFx, 1);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('deadbeeffeebdaed'),
|
|
'',
|
|
TFormat_HexL.Decode('2dfb9508c07cd1521849d8dd92585ec0'+
|
|
'9499132de0f6b8d4ed2768ec1c83f0ed'),
|
|
32, THash_SHA1, ktKDFx, 2);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('7e335afa4b31d772c0635c7b0e06f26f' +
|
|
'cd781df947d2990a'),
|
|
TFormat_HexL.Decode('d65a4812733f8cdbcdfb4b2f4c191d87'),
|
|
TFormat_HexL.Decode('934006d019879d1ee2787b27ed57841b' +
|
|
'66433425d6a0f4ca6abb20f6967dc660' +
|
|
'd04f8577b13ec8d4ec54610a78e0881f' +
|
|
'2ae26f482c81053c6d8951e787b2e4a9' +
|
|
'9b3c2a95bc196948e1f1819c55ba08d6' +
|
|
'6a6ca395e9929eaee752b5dc324e980d' +
|
|
'71f0e8c1b244bb3b0c09b903ebc446e2' +
|
|
'925bf1a7041923a3910959e5dcd6afd2'),
|
|
128, THash_SHA256, ktKDFx, 1);
|
|
|
|
FTestData.Add(TFormat_HexL.Decode('7e335afa4b31d772c0635c7b0e06f26f' +
|
|
'cd781df947d2990a'),
|
|
TFormat_HexL.Decode('d65a4812733f8cdbcdfb4b2f4c191d87'),
|
|
TFormat_HexL.Decode('2c26a1303d2146d61384e689debf541f' +
|
|
'bcd832e9343f2771b7e28dd877f096d5' +
|
|
'95e0e12c768d74d72a91176908b34842' +
|
|
'a0a32d7b3f8293d169fa873a5a7e747e' +
|
|
'0e6e054e73c2ca1bb89a1772e4e5b0f6' +
|
|
'7cead338829bb02e7012254f4f79e63a' +
|
|
'619e6f14782af946e169c2870ec6ca3a' +
|
|
'68377d2ad42196987278f93674c7d861'),
|
|
128, THash_SHA256, ktKDFx, 2);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TearDown;
|
|
begin
|
|
FTestData.Free;
|
|
|
|
inherited;
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF1;
|
|
begin
|
|
InternalTest(ktKDF1);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF1TBytes;
|
|
begin
|
|
InternalTestTBytes(ktKDF1);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF2;
|
|
begin
|
|
InternalTest(ktKDF2);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF2TBytes;
|
|
begin
|
|
InternalTestTBytes(ktKDF2);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF3;
|
|
begin
|
|
InternalTest(ktKDF3);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDF3TBytes;
|
|
begin
|
|
InternalTestTBytes(ktKDF3);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDFx;
|
|
begin
|
|
InternalTest(ktKDFx);
|
|
end;
|
|
|
|
procedure TestTHash_KDF.TestKDFxTBytes;
|
|
begin
|
|
InternalTestTBytes(ktKDFx);
|
|
end;
|
|
|
|
{ THash_TestMGF1 }
|
|
|
|
procedure TestTHash_MGF1.SetUp;
|
|
begin
|
|
inherited;
|
|
|
|
FTestData := TKeyDeviationTestList.Create;
|
|
|
|
FTestData.Add('foo', '1ac907', 3, THash_SHA1, ktMGF1);
|
|
FTestData.Add('foo', '1ac9075cd4', 5, THash_SHA1, ktMGF1);
|
|
FTestData.Add('bar', 'bc0c655e01', 5, THash_SHA1, ktMGF1);
|
|
FTestData.Add('bar', 'bc0c655e016bc2931d85a2e675181adcef7f581f76df2739da74f' +
|
|
'aac41627be2f7f415c89e983fd0ce80ced9878641cb4876', 50, THash_SHA1, ktMGF1);
|
|
FTestData.Add('bar', '382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735' +
|
|
'd10dc724b155f9f6069f289d61daca0cb814502ef04eae1', 50, THash_SHA256, ktMGF1);
|
|
|
|
FTestData.Add('foo', 'b2ae0e', 3, THash_SHA1, ktMGFx, 1);
|
|
FTestData.Add('foo', '44ffe3', 3, THash_SHA1, ktMGFx, 2);
|
|
FTestData.Add('foo', 'b2ae0e6e26', 5, THash_SHA1, ktMGFx, 1);
|
|
FTestData.Add('foo', '44ffe3a40b', 5, THash_SHA1, ktMGFx, 2);
|
|
FTestData.Add('bar', '21dfca12e1', 5, THash_SHA1, ktMGFx, 1);
|
|
FTestData.Add('bar', '596eb7fe1b', 5, THash_SHA1, ktMGFx, 2);
|
|
FTestData.Add('bar', '21dfca12e13ebcaa77a5b6c0ff7023266e0dd54498306070fc735' +
|
|
'ad7b0d88e14cb1acc887f564c7adb677a1b6b4b1e6b3f07', 50, THash_SHA1, ktMGFx, 1);
|
|
FTestData.Add('bar', '596eb7fe1ba0a133e7c445c745270bf6433dc88cef9f922840f75' +
|
|
'd4867a247ea37fc9458c934e4675bcd7300722ee8d07b37', 50, THash_SHA1, ktMGFx, 2);
|
|
FTestData.Add('bar', 'e01f7238400a2f1501bbaaf937d3d081bda4fe5bccc713134f5d3' +
|
|
'a580bd66783d379e6d91c6e91a1072744ae42fe4e182f32', 50, THash_SHA256, ktMGFx, 1);
|
|
FTestData.Add('bar', '816453f0040d4f0469ccfcb520bf63fbf4616e46adff6708d40b1' +
|
|
'63041b91a234baa7f8a1fb86b23ef81df6e1121233dd88e', 50, THash_SHA256, ktMGFx, 2);
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TearDown;
|
|
begin
|
|
FTestData.Free;
|
|
|
|
inherited;
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestMGF1RawMemory;
|
|
begin
|
|
TestRawMemoryInternal(ktMGF1)
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestMGF1TBytes;
|
|
begin
|
|
TestTBytesInternal(ktMGF1);
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestMGFxRawMemory;
|
|
begin
|
|
TestRawMemoryInternal(ktMGFx)
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestMGFxTBytes;
|
|
begin
|
|
TestTBytesInternal(ktMGFx);
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestRawMemoryInternal(Algorithm : TKDFMGFAlgorithm);
|
|
var
|
|
InputData : TBytes;
|
|
OutputData : TBytes;
|
|
i : Integer;
|
|
begin
|
|
for i := 0 to FTestData.Count - 1 do
|
|
begin
|
|
InputData := BytesOf(FTestData[i].InputData);
|
|
|
|
// Skip tests which are not for the selected algorithm
|
|
if FTestData[i].Algorithm <> Algorithm then
|
|
Continue;
|
|
|
|
case FTestData[i].Algorithm of
|
|
ktMGF1 : OutputData := FTestData[i].HashClass.MGF1(InputData[0], length(InputData),
|
|
FTestData[i].MaskSize);
|
|
ktMGFx : OutputData := FTestData[i].HashClass.MGFx(InputData[0], length(InputData),
|
|
FTestData[i].MaskSize, FTestData[i].Index);
|
|
end;
|
|
|
|
CheckEquals(FTestData[i].OutputData,
|
|
DECUtil.BytesToRawString(TFormat_HEXL.Encode(OutputData)),
|
|
'MGFT1/MGFx test failed at index ' + IntToStr(i));
|
|
end;
|
|
end;
|
|
|
|
procedure TestTHash_MGF1.TestTBytesInternal(Algorithm : TKDFMGFAlgorithm);
|
|
var
|
|
InputData : TBytes;
|
|
OutputData : TBytes;
|
|
i : Integer;
|
|
begin
|
|
for i := 0 to FTestData.Count - 1 do
|
|
begin
|
|
InputData := BytesOf(FTestData[i].InputData);
|
|
|
|
// Skip tests which are not for the selected algorithm
|
|
if FTestData[i].Algorithm <> Algorithm then
|
|
Continue;
|
|
|
|
case FTestData[i].Algorithm of
|
|
ktMGF1 : OutputData := FTestData[i].HashClass.MGF1(InputData, FTestData[i].MaskSize);
|
|
ktMGFx : OutputData := FTestData[i].HashClass.MGFx(InputData, FTestData[i].MaskSize,
|
|
FTestData[i].Index);
|
|
end;
|
|
|
|
CheckEquals(FTestData[i].OutputData,
|
|
DECUtil.BytesToRawString(TFormat_HEXL.Encode(OutputData)),
|
|
'MGF1/MGFx test failed at index ' + IntToStr(i));
|
|
end;
|
|
end;
|
|
|
|
initialization
|
|
// Register any test cases with the test runner
|
|
{$IFDEF DUnitX}
|
|
TDUnitX.RegisterTestFixture(TestTHash_MGF1);
|
|
TDUnitX.RegisterTestFixture(TestTHash_KDF);
|
|
{$ELSE}
|
|
RegisterTests('DECHashKDF', [TestTHash_MGF1.Suite,
|
|
TestTHash_KDF.Suite]);
|
|
{$ENDIF}
|
|
end.
|