public void LegacyExtendStaticTest()
{
IKsiSignature signature = new KsiSignatureFactory().Create(File.ReadAllBytes(Path.Combine(TestSetup.LocalPath, Resources.KsiSignature_Ok)));
Ksi ksi = GetStaticKsi(Resources.KsiService_LegacyExtendResponsePdu, 3491956840, null, PduVersion.v1);
Verify(ksi.Extend(signature));
}
public void HAExtenderGetConfTest()
{
Ksi ksi = new Ksi(new HAKsiService(null, ExtendingServices, null));
ExtenderConfig conf = ksi.GetExtenderConfig();
Assert.NotNull(conf);
}
public void HAAggregatorGetConfTest()
{
Ksi ksi = new Ksi(new HAKsiService(SigningServices, null, null));
AggregatorConfig conf = ksi.GetAggregatorConfig();
Assert.NotNull(conf);
}
public void ExtendSuccessWithInvalidSigningPassTest(Ksi ksi)
{
Assert.DoesNotThrow(delegate
{
ksi.Extend(TestUtil.GetSignature());
}, "Invalid signing pass should not prevent extending.");
}
private static void Verify(Ksi ksi, IKsiSignature signature, DataHash documentHash)
{
VerificationContext verificationContext = new VerificationContext(signature)
{
DocumentHash = documentHash,
PublicationsFile = ksi.GetPublicationsFile()
};
AggregationHashChain.Link firstChainLink = signature.GetAggregationHashChains()[0].GetChainLinks()[0];
if (firstChainLink.Metadata != null && firstChainLink.Metadata.Padding == null)
{
throw new Exception("Metadata padding is missing.");
}
KeyBasedVerificationPolicy policy = new KeyBasedVerificationPolicy();
VerificationResult verificationResult = policy.Verify(verificationContext);
if (verificationResult.ResultCode != VerificationResultCode.Ok)
{
Console.WriteLine("Verification result code: " + verificationResult.ResultCode);
Console.WriteLine("Verification rule name: " + verificationResult.RuleName);
Console.WriteLine("Verification error: " + verificationResult.VerificationError);
}
Assert.AreEqual(VerificationResultCode.Ok, verificationResult.ResultCode, "Signature should verify with key based policy");
}
public void BlockSignerGetUniSignaturesOfManyRandomHashesTest(Ksi ksi)
{
int k = 7;
Random random = new Random();
IdentityMetadata metadata = new IdentityMetadata("test client id", "test machine id");
List <DataHash> hashes = new List <DataHash>();
byte[] buffer = new byte[10];
for (int i = 0; i < k; i++)
{
IDataHasher hasher = KsiProvider.CreateDataHasher();
random.NextBytes(buffer);
hasher.AddData(buffer);
hashes.Add(hasher.GetHash());
}
BlockSigner blockSigner = new BlockSigner(GetHttpKsiService());
foreach (DataHash hash in hashes)
{
blockSigner.Add(hash, metadata);
}
IEnumerable <IKsiSignature> uniSignatures = blockSigner.Sign();
int n = 0;
foreach (IKsiSignature signature in uniSignatures)
{
Verify(ksi, signature, hashes[n++]);
}
}
public void TcpGetExtenderConfigSuccessWithInvalidSigningPortTest(Ksi ksi)
{
Assert.DoesNotThrow(delegate
{
ksi.GetExtenderConfig();
}, "Invalid signing port should not prevent getting extender config.");
}
public void SignHashWithTcpTimeoutAndBufferSizeTest()
{
uint requestTimeout = 9000;
uint bufferSize = 1024;
TcpKsiSigningServiceProtocol protocol = new TcpKsiSigningServiceProtocol(
IPAddress.Parse(Settings.Default.TcpExtendingServiceIp),
Settings.Default.TcpSigningServicePort,
requestTimeout,
bufferSize);
HttpKsiServiceProtocol publicationsFileProtocol = new HttpKsiServiceProtocol(
null,
null,
Settings.Default.HttpPublicationsFileUrl);
Ksi ksi = new Ksi(new KsiService(
protocol,
new ServiceCredentials(Settings.Default.HttpSigningServiceUser, Settings.Default.HttpSigningServicePass,
TestUtil.GetHashAlgorithm(Settings.Default.HttpSigningServiceHmacAlgorithm)),
null, null, publicationsFileProtocol,
new PublicationsFileFactory(
new PkiTrustStoreProvider(new X509Store(StoreName.Root), CryptoTestFactory.CreateCertificateSubjectRdnSelector("[email protected]")))));
VerificationResult verificationResult = SignHash(ksi);
Assert.AreEqual(VerificationResultCode.Ok, verificationResult.ResultCode, "Signature should verify with key based policy");
}
public void BlockSignerGetUniSignaturesWithoutHashesTest(Ksi ksi)
{
BlockSigner blockSigner = new BlockSigner(GetHttpKsiService());
IEnumerable <IKsiSignature> result = blockSigner.Sign();
Assert.AreEqual(0, result.Count(), "Unexpected signature count");
}
public void Verify(Ksi ksi)
{
VerificationResult result = ksi.Verify(TestUtil.GetSignature(Resources.KsiSignature_Ok));
Assert.AreEqual(VerificationResultCode.Ok, result.ResultCode, "Unexpected verification result code.");
Assert.AreEqual(nameof(DefaultVerificationPolicy), result.RuleName, "Unexpected policy used.");
}
public void TcpSignHashSuccessWithInvalidExtendingPortTest(Ksi ksi)
{
Assert.DoesNotThrow(delegate
{
SignHash(ksi);
}, "Invalid exteding port should not prevent signing.");
}
public void SignWithStreamAndLevelTest(Ksi ksi)
{
IKsiSignature signature;
using (MemoryStream stream = new MemoryStream())
{
byte[] data = Encoding.UTF8.GetBytes("This is my document");
stream.Write(data, 0, data.Length);
stream.Seek(0, SeekOrigin.Begin);
signature = ksi.Sign(stream, 3);
}
Assert.LessOrEqual(3, signature.GetAggregationHashChains()[0].GetChainLinks()[0].LevelCorrection, "Level correction is invalid.");
VerificationContext verificationContext = new VerificationContext(signature)
{
DocumentHash = new DataHash(HashAlgorithm.Sha2256,
Base16.Decode("D439459856BEF5ED25772646F73A70A841FC078D3CBBC24AB7F47C464683768D")),
PublicationsFile = ksi.GetPublicationsFile()
};
KeyBasedVerificationPolicy policy = new KeyBasedVerificationPolicy();
VerificationResult verificationResult = policy.Verify(verificationContext);
Assert.AreEqual(VerificationResultCode.Ok, verificationResult.ResultCode, "Signature should verify with key based policy");
}
public void ExtendStaticTest()
{
IKsiSignature signature = new KsiSignatureFactory().Create(File.ReadAllBytes(Path.Combine(TestSetup.LocalPath, Resources.KsiSignature_Ok)));
Ksi ksi = GetStaticKsi(Resources.KsiService_ExtendResponsePdu_RequestId_1043101455, 1043101455);
Verify(ksi.Extend(signature));
}
public void TcpGetAggregatorConfigWithInvalidExtendingPortTest(Ksi ksi)
{
Assert.DoesNotThrow(delegate
{
ksi.GetAggregatorConfig();
}, "Invalid exteding port should not prevent signing.");
}
public void SignStaticTest()
{
Ksi ksi = GetStaticKsi(Resources.KsiService_AggregationResponsePdu_RequestId_1584727637, 1584727637);
DataHash dataHash = new DataHash(Base16.Decode("019f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
IKsiSignature signature = ksi.Sign(dataHash);
Verify(signature, dataHash);
}
public void GetPublicationsFileStaticTest()
{
Ksi ksi = GetKsi();
IPublicationsFile pubFile = ksi.GetPublicationsFile();
Assert.AreEqual(1515974400, pubFile.GetLatestPublication().PublicationData.PublicationTime, "Unexpected last publication time");
}
public void ExtendStaticWithMultiPayloadsResponseTest()
{
IKsiSignature signature = new KsiSignatureFactory().Create(File.ReadAllBytes(Path.Combine(TestSetup.LocalPath, Resources.KsiSignature_Ok)));
// Response has multiple payloads (2 extending payloads and a configuration payload)
Ksi ksi = GetStaticKsi(Resources.KsiService_ExtendResponsePdu_Multi_Payloads, 1043101455, new KsiSignatureFactory(new EmptyVerificationPolicy()));
Verify(ksi.Extend(signature));
}
public void VerifyNewSignature(Ksi ksi)
{
IKsiSignature signature = ksi.Sign(new DataHash(Base16.Decode("0111A700B0C8066C47ECBA05ED37BC14DCADB238552D86C659342D1D7E87B8772D")));
VerificationResult result = ksi.Verify(signature);
Assert.AreEqual(VerificationResultCode.Ok, result.ResultCode, "Unexpected verification result code.");
Assert.AreEqual(nameof(DefaultVerificationPolicy), result.RuleName, "Unexpected policy used.");
}
public void VerifyWithDocumentHashAndPublicationsFile(Ksi ksi)
{
VerificationResult result = ksi.Verify(TestUtil.GetSignature(Resources.KsiSignature_Ok),
new DataHash(Base16.Decode("0111A700B0C8066C47ECBA05ED37BC14DCADB238552D86C659342D1D7E87B8772D")), TestUtil.GetPublicationsFile());
Assert.AreEqual(VerificationResultCode.Ok, result.ResultCode, "Unexpected verification result code.");
Assert.AreEqual(nameof(DefaultVerificationPolicy), result.RuleName, "Unexpected policy used.");
}
public void VerifyWithVerificationContextNull(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
ksi.Verify(new DefaultVerificationPolicy(), null);
});
Assert.AreEqual("context", ex.ParamName);
}
public void VerifyWithVerificationPolicyNull(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
ksi.Verify((VerificationPolicy)null, null);
});
Assert.AreEqual("policy", ex.ParamName);
}
public void VerifyWithSignatureNull2(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
ksi.Verify(null, null, TestUtil.GetPublicationsFile());
});
Assert.AreEqual("ksiSignature", ex.ParamName);
}
public void VerifyWithSignatureNull(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
ksi.Verify(null);
});
Assert.AreEqual("ksiSignature", ex.ParamName);
}
public void CreateKsiWithServiceNull()
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
Ksi ksi = new Ksi(null);
});
Assert.AreEqual("ksiService", ex.ParamName);
}
public void VerifyFailWithInvalidDocumentHash(Ksi ksi)
{
VerificationResult result = ksi.Verify(TestUtil.GetSignature(Resources.KsiSignature_Ok),
new DataHash(Base16.Decode("01580192B0D06E48884432DFFC26A67C6C685BEAF0252B9DD2A0B4B05D1724C5F2")));
Assert.AreEqual(VerificationResultCode.Fail, result.ResultCode);
Assert.AreEqual(VerificationError.Gen01, result.VerificationError);
Assert.AreEqual(nameof(DefaultVerificationPolicy), result.RuleName, "Unexpected policy used.");
}
public void VerifyWithPublicationsFileNull(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
ksi.Verify(TestUtil.GetSignature(Resources.KsiSignature_Ok), null, null);
});
Assert.AreEqual("publicationsFile", ex.ParamName);
}
public void BlockSignerWithoutServiceTest(Ksi ksi)
{
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
BlockSigner blockSigner = new BlockSigner(null, true, null);
});
Assert.AreEqual("ksiService", ex.ParamName, "Unexpected exception message");
}
public void BlockSignerWithoutRandomSeedTest(Ksi ksi)
{
BlockSigningException ex = Assert.Throws <BlockSigningException>(delegate
{
BlockSigner blockSigner = new BlockSigner(GetHttpKsiService(), true, null);
});
Assert.That(ex.Message, Does.StartWith("Random seed cannot be null when using blinding masks"), "Unexpected exception message");
}
public void ExtendInvalidPassTest(Ksi ksi)
{
Exception ex = Assert.Throws <KsiServiceException>(delegate
{
ksi.Extend(TestUtil.GetSignature());
});
Assert.AreEqual("Server responded with error message. Status: 258; Message: Failed hmac check.", ex.Message);
}
public void ExtendToNearestPublicationTest(Ksi ksi)
{
IKsiSignature ksiSignature = TestUtil.GetSignature();
IKsiSignature extendedToLatest = ksi.Extend(ksiSignature, ksi.GetPublicationsFile().GetLatestPublication());
IKsiSignature extendedToNearest = ksi.Extend(ksiSignature);
Assert.True(extendedToLatest.PublicationRecord.PublicationData.PublicationTime > extendedToNearest.PublicationRecord.PublicationData.PublicationTime);
Assert.AreEqual(1455494400, extendedToNearest.PublicationRecord.PublicationData.PublicationTime);
}
