public void AsyncSignWithInvalidPassTest(KsiService service)
{
byte[] data = Encoding.UTF8.GetBytes("This is my document");
IDataHasher dataHasher = KsiProvider.CreateDataHasher();
dataHasher.AddData(data);
DataHash dataHash = dataHasher.GetHash();
ManualResetEvent waitHandle = new ManualResetEvent(false);
Exception ex = null;
IKsiSignature signature = null;
service.BeginSign(dataHash, delegate(IAsyncResult ar)
{
try
{
signature = service.EndSign(ar);
}
catch (Exception e)
{
ex = e;
}
finally
{
waitHandle.Set();
}
}, null);
Assert.IsTrue(waitHandle.WaitOne(10000), "Wait handle timed out.");
Assert.IsNull(signature, "Signature should be null.");
Assert.IsNotNull(ex, "Exception should not be null.");
Assert.AreEqual("Server responded with error message. Status: 258; Message: The request could not be authenticated.", ex.Message);
}
public void TcpSignHashWithReusedSocketTest()
{
KsiService service = GetTcpKsiService();
DataHash hash1 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
DataHash hash2 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
DataHash hash3 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
DataHash hash4 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
IAsyncResult ar1 = service.BeginSign(hash1, null, null);
IAsyncResult ar2 = service.BeginSign(hash2, null, null);
IKsiSignature sig1 = service.EndSign(ar1);
Assert.AreEqual(hash1, sig1.InputHash, "Unexpected signature input hash");
IKsiSignature sig2 = service.EndSign(ar2);
Assert.AreEqual(hash2, sig2.InputHash, "Unexpected signature input hash");
Socket socket1 = GetSigningSocket(service);
IAsyncResult ar3 = service.BeginSign(hash3, null, null);
IAsyncResult ar4 = service.BeginSign(hash4, null, null);
IKsiSignature sig3 = service.EndSign(ar3);
Assert.AreEqual(hash3, sig3.InputHash, "Unexpected signature input hash");
IKsiSignature sig4 = service.EndSign(ar4);
Assert.AreEqual(hash4, sig4.InputHash, "Unexpected signature input hash");
Socket socket2 = GetSigningSocket(service);
Assert.AreEqual(socket1, socket2, "Sockets should be equal");
}
public void VerifyExtendedSignatureUsingDefaultPolicy()
{
// Create simple wrapper.
KSI.Ksi ksi = GetKsi();
// Read the existing signature, assume it is extended
IKsiSignature signature = LoadExtendedSignature();
DataHash documentHash = KsiProvider.CreateDataHasher(signature.InputHash.Algorithm)
.AddData(File.ReadAllBytes("Resources/infile.txt"))
.GetHash();
// Do the verification and check the result.
// The signature is verified against given document hash and publications file (publications file is automatically downloaded by simple wrapper).
VerificationResult verificationResult = ksi.Verify(signature, documentHash);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyExtendedSignatureUsingDefaultPolicy > signature valid");
}
else
{
Console.WriteLine("VerifyExtendedSignatureUsingDefaultPolicy > verification failed with error > " + verificationResult.VerificationError);
}
}
public void VerifyUnextendedSignatureUsingDefaultPolicy()
{
// Create simple wrapper.
KSI.Ksi ksi = GetKsi();
// Read signature, assume to be not extended
IKsiSignature signature = LoadUnextendedSignature();
// We need to compute the hash from the original data, to make sure it
// matches the one in the signature and has not been changed
// Use the same algorithm as the input hash in the signature
DataHash documentHash = KsiProvider.CreateDataHasher(signature.InputHash.Algorithm)
.AddData(File.ReadAllBytes("Resources/infile.txt"))
.GetHash();
// Do the verification and check the result.
// At first KSI signature is verified against given document hash.
// Then the signature is extended. If extending succeeds then the signature is verified
// against publications file (publications file is automatically downloaded by simple wrapper).
// If extending is not yet possible then key based verification is done.
VerificationResult verificationResult = ksi.Verify(signature, documentHash);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyUnextendedSignatureUsingDefaultPolicy > signature valid");
}
else
{
Console.WriteLine("VerifyUnextendedSignatureUsingDefaultPolicy > verification failed with error > " + verificationResult.VerificationError);
}
}
public void VerifyExtendedSignatureUsingPublicationsFile()
{
KSI.Ksi ksi = GetKsi();
// Read the existing signature, assume it is extended
IKsiSignature signature = LoadExtendedSignature();
DataHash documentHash = KsiProvider.CreateDataHasher(signature.InputHash.Algorithm)
.AddData(File.ReadAllBytes("Resources/infile.txt"))
.GetHash();
// Do the verification and check the result
VerificationPolicy policy = new PublicationBasedVerificationPolicy();
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = documentHash,
PublicationsFile = ksi.GetPublicationsFile(),
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsFile > signature valid");
}
else
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsFile > verification failed with error > " + verificationResult.VerificationError);
}
}
public void TcpSignHashesWithSocketReuseAndTimeoutTest()
{
KsiService service = GetTcpKsiService();
DataHash hash1 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
DataHash hash2 = new DataHash(HashAlgorithm.Sha2256, Base16.Decode("1f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
IAsyncResult ar1 = service.BeginSign(hash1, null, null);
IKsiSignature sig1 = service.EndSign(ar1);
Socket socket1 = GetSigningSocket(service);
Assert.AreEqual(hash1, sig1.InputHash, "Unexpected signature input hash");
Socket socket2 = GetSigningSocket(service);
Assert.AreEqual(socket1, socket2, "Sockets should be equal");
// after 20 sec server will close connection
Thread.Sleep(22000);
IAsyncResult ar2 = service.BeginSign(hash2, null, null);
IKsiSignature sig2 = service.EndSign(ar2);
Assert.AreEqual(hash2, sig2.InputHash, "Unexpected signature input hash");
socket2 = GetSigningSocket(service);
Assert.AreNotEqual(socket1, socket2, "Sockets should not be equal");
}
/// <summary>
/// Create uni-signatures based on the root signature.
/// </summary>
/// <returns></returns>
private IEnumerable <IKsiSignature> CreateUniSignatures(IKsiSignature rootSignature)
{
Logger.Debug("Start creating uni-signatures.");
AggregationHashChain existingAggregationHashChain = rootSignature.GetAggregationHashChains()[0];
byte[] rootSignatureData = rootSignature.EncodeValue();
ulong[] chainIndex = PrepareChainIndex(existingAggregationHashChain);
foreach (TreeNode node in _leafNodes)
{
using (MemoryStream stream = new MemoryStream())
{
AggregationHashChain aggregationHashChain = GetAggregationHashChain(existingAggregationHashChain, node, chainIndex);
aggregationHashChain.WriteTo(stream);
// Take root node signature data and add aggregation hash chain.
byte[] signatureData = new byte[rootSignatureData.Length + stream.Length];
Array.Copy(stream.ToArray(), signatureData, stream.Length);
Array.Copy(rootSignatureData, 0, signatureData, stream.Length, rootSignatureData.Length);
// Create new signature from the signature data.
yield return(_signatureFactory.CreateByContent(signatureData, node.Hash));
}
}
Logger.Debug("End creating uni-signatures.");
}
public void ExtendToGivenPublicationDate()
{
KSI.Ksi ksi = GetKsi();
IKsiSignature signature = LoadUnextendedSignature();
PublicationRecordInPublicationFile publicationRecord = ksi.GetPublicationsFile().GetNearestPublicationRecord(new DateTime(2016, 2, 15));
if (publicationRecord == null)
{
Console.WriteLine("ExtendToGivenPublicationDate > no suitable publication yet. signature not extended");
return;
}
Console.WriteLine("ExtendToGivenPublicationDate > trying to extend signature to publication > "
+ Util.ConvertUnixTimeToDateTime(publicationRecord.PublicationData.PublicationTime));
IKsiSignature extendedSignature = ksi.Extend(signature, publicationRecord);
if (extendedSignature.IsExtended)
{
Console.WriteLine("ExtendToGivenPublicationDate > signature extended to publication > "
+ Util.ConvertUnixTimeToDateTime(extendedSignature.PublicationRecord.PublicationData.PublicationTime));
// Store the extended signature
// ...
}
else
{
Console.WriteLine("ExtendToGivenPublicationDate > signature not extended");
}
}
public void TestKsiSignatureOk()
{
IKsiSignature signature = GetKsiSignatureFromFile(Resources.KsiSignature_Ok);
Assert.NotNull(signature.CalendarHashChain, "Calendar hash chain cannot be null");
Assert.NotNull(signature.CalendarAuthenticationRecord, "Calendar auth record cannot be null");
}
public void PrintCalendarHashChain()
{
IKsiSignature signature = LoadExtendedSignature();
Console.WriteLine("PrintCalendarHashChain > publication time > " + Util.ConvertUnixTimeToDateTime(signature.CalendarHashChain.PublicationTime));
Console.WriteLine("PrintCalendarHashChain > aggregation time > " + Util.ConvertUnixTimeToDateTime(signature.CalendarHashChain.AggregationTime));
}
public void VerifyExtendedSignatureUsingPublicationsCodeAutoExtend()
{
// Read signature, assume to be not extended
IKsiSignature signature = LoadUnextendedSignature();
IDataHasher dataHasher = new DataHasher(signature.GetAggregationHashChains()[0].InputHash.Algorithm);
dataHasher.AddData(File.ReadAllBytes("Resources/infile.txt"));
PublicationData publicationData = new PublicationData("AAAAAA-CWYEKQ-AAIYPA-UJ4GRT-HXMFBE-OTB4AB-XH3PT3-KNIKGV-PYCJXU-HL2TN4-RG6SCC-3ZGSBM");
// Do the verification and check the result
VerificationPolicy policy = new PublicationBasedVerificationPolicy();
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = dataHasher.GetHash(),
UserPublication = publicationData,
IsExtendingAllowed = true,
KsiService = GetKsiService(),
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsCodeAutoExtend > signature valid");
}
else
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsCodeAutoExtend > signature verification failed with error > " + verificationResult.VerificationError);
}
}
/// <see cref="VerificationRule.Verify" />
public override VerificationResult Verify(IVerificationContext context)
{
IKsiSignature signature = GetSignature(context);
PublicationData publicationData;
if (context.UserPublication != null)
{
publicationData = context.UserPublication;
}
else
{
PublicationRecordInPublicationFile publicationRecord = GetNearestPublicationRecord(GetPublicationsFile(context), signature.AggregationTime, true);
if (publicationRecord == null)
{
// if suitable publication record does not exist in publications file then return NA
return(new VerificationResult(GetRuleName(), VerificationResultCode.Na, VerificationError.Gen02));
}
publicationData = publicationRecord.PublicationData;
}
CalendarHashChain extendedCalendarHashChain = GetExtendedCalendarHashChain(context, publicationData.PublicationTime);
HashAlgorithm deprecatedHashAlgorithm = GetDeprecatedHashAlgorithm(extendedCalendarHashChain);
if (deprecatedHashAlgorithm != null)
{
Logger.Debug("Extender response calendar hash chain contains deprecated aggregation algorithm at publication time. Algorithm: {0}; Publication time: {1}",
deprecatedHashAlgorithm.Name, extendedCalendarHashChain.PublicationTime);
return(new VerificationResult(GetRuleName(), VerificationResultCode.Na, VerificationError.Gen02));
}
return(new VerificationResult(GetRuleName(), VerificationResultCode.Ok));
}
public void ExtendToClosestPublication()
{
KSI.Ksi ksi = GetKsi();
// Read an existing signature from file, assume it to be not extended
IKsiSignature signature = LoadUnextendedSignature();
// Extends the signature to the closest publication found in the publications file
// Assumes signature is not extended and at least one publication after
// the signature obtained
IKsiSignature extendedSignature = ksi.Extend(signature);
// Double check if signature was extended
if (extendedSignature.IsExtended)
{
Console.WriteLine("ExtendToClosestPublication > extended to publication > " +
Util.ConvertUnixTimeToDateTime(extendedSignature.PublicationRecord.PublicationData.PublicationTime));
}
else
{
Console.WriteLine("ExtendToClosestPublication > signature not extended");
}
// Store the extended signature
//using (FileStream stream = File.Create("sample-file-for-signing.txt.extended.ksig"))
//{
// extendedSignature.WriteTo(stream);
//}
}
public void VerifyKeyBased()
{
KSI.Ksi ksi = GetKsi();
// Read signature, assume to be not extended
IKsiSignature signature = LoadUnextendedSignature();
IDataHasher dataHasher = new DataHasher(signature.GetAggregationHashChains()[0].InputHash.Algorithm);
dataHasher.AddData(File.ReadAllBytes("Resources/infile.txt"));
VerificationPolicy policy = new KeyBasedVerificationPolicy(new X509Store(StoreName.Root), GetCertificateSubjectRdnSelector());
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = dataHasher.GetHash(),
PublicationsFile = ksi.GetPublicationsFile(),
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyKeyBased > signature valid");
}
else
{
Console.WriteLine("VerifyKeyBased > signature verification failed with error > " + verificationResult.VerificationError);
}
}
public void VerifyCalendarBasedUnextended()
{
IKsiSignature signature = LoadUnextendedSignature();
IDataHasher dataHasher = new DataHasher(signature.GetAggregationHashChains()[0].InputHash.Algorithm);
dataHasher.AddData(File.ReadAllBytes("Resources/infile.txt"));
VerificationPolicy policy = new CalendarBasedVerificationPolicy();
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = dataHasher.GetHash(),
KsiService = GetKsiService(),
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyCalendarBasedUnextended > signature valid");
}
else
{
Console.WriteLine("VerifyCalendarBasedUnextended > signature verification failed with error > " + verificationResult.VerificationError);
}
}
public void HAAsyncSignTest()
{
HAKsiService haService = new HAKsiService(SigningServices, ExtendingServices, PublicationsFileService);
DataHash dataHash = new DataHash(Base16.Decode("019f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"));
ManualResetEvent waitHandle = new ManualResetEvent(false);
IKsiSignature signature = null;
object testObject = new object();
bool isAsyncStateCorrect = false;
haService.BeginSign(dataHash, delegate(IAsyncResult ar)
{
try
{
isAsyncStateCorrect = ar.AsyncState == testObject;
signature = haService.EndSign(ar);
}
finally
{
waitHandle.Set();
}
}, testObject);
Assert.IsTrue(waitHandle.WaitOne(10000), "Wait handle timed out.");
Assert.IsNotNull(signature, "Signature should not be null.");
Assert.AreEqual(true, isAsyncStateCorrect, "Unexpected async state.");
}
public void SignHashDirectly()
{
KSI.Ksi ksi = GetKsi();
// Compute the hash first, use the input stream to provide the data to save memory for
// hashing very large documents
// In this example we simply use an input stream from an array of bytes but in practice it
// could be file input stream from a very large file (several GB)
IDataHasher dataHasher = KsiProvider.CreateDataHasher();
using (MemoryStream stream = new MemoryStream())
{
byte[] data = Encoding.UTF8.GetBytes("Imagine this is a large file");
stream.Write(data, 0, data.Length);
stream.Seek(0, SeekOrigin.Begin);
dataHasher.AddData(stream);
}
// Provide the signing method with the computed hash instead of document itself
IKsiSignature signature = ksi.Sign(dataHasher.GetHash());
// Persist signature to file
//using (FileStream stream = File.OpenRead("sample-file-for-signing.txt.ksig"))
//{
// signature.WriteTo(stream);
//}
}
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 VerifyExtendedSignatureUsingPublicationsFile()
{
KSI.Ksi ksi = GetKsi();
// Read the existing signature, assume it is extended
IKsiSignature signature = LoadExtendedSignature();
// We need to compute the hash from the original data, to make sure it
// matches the one in the signature and has not been changed
// Use the same algorithm as the input hash in the signature
IDataHasher dataHasher = new DataHasher(signature.GetAggregationHashChains()[0].InputHash.Algorithm);
dataHasher.AddData(File.ReadAllBytes("Resources/infile.txt"));
// Do the verification and check the result
VerificationPolicy policy = new PublicationBasedVerificationPolicy();
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = dataHasher.GetHash(),
PublicationsFile = ksi.GetPublicationsFile(),
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsFile > signature valid");
}
else
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsFile > verification failed with error > " + verificationResult.VerificationError);
}
}
public void VerifyExtendedSignatureUsingPublicationsCode()
{
// Read the existing signature, assume it is extended
IKsiSignature signature = LoadExtendedSignature();
IDataHasher dataHasher = new DataHasher(signature.GetAggregationHashChains()[0].InputHash.Algorithm);
dataHasher.AddData(File.ReadAllBytes("Resources/infile.txt"));
// The trust anchor in this example is the publication code in Financial Times or on Twitter
PublicationData publicationData = new PublicationData("AAAAAA-CWYEKQ-AAIYPA-UJ4GRT-HXMFBE-OTB4AB-XH3PT3-KNIKGV-PYCJXU-HL2TN4-RG6SCC-3ZGSBM");
// Do the verification and check the result
VerificationPolicy policy = new PublicationBasedVerificationPolicy();
VerificationContext context = new VerificationContext(signature)
{
DocumentHash = dataHasher.GetHash(),
UserPublication = publicationData
};
VerificationResult verificationResult = policy.Verify(context);
if (verificationResult.ResultCode == VerificationResultCode.Ok)
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsCode > signature valid");
}
else
{
Console.WriteLine("VerifyExtendedSignatureUsingPublicationsCode > signature verification failed with error > " + verificationResult.VerificationError);
}
}
public void TestKsiSignatureOkWithAggregationHashChainOnly()
{
IKsiSignature signature = GetKsiSignatureFromFile(Resources.KsiSignature_Ok_AggregationHashChain_Only);
Assert.Null(signature.CalendarHashChain, "Calendar hash chain must be null");
Assert.Null(signature.PublicationRecord, "Publication record must be null");
Assert.Null(signature.CalendarAuthenticationRecord, "Calendar authentication record must be null");
}
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 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);
}
/// <summary>
/// Extend signature to publication.
/// </summary>
/// <param name="calendarHashChain">extended calendar hash chain</param>
/// <param name="publicationRecord">extended publication record</param>
/// <param name="signatureFactory">signature factory to be used when creating extended signature</param>
/// <returns>extended KSI signature</returns>
public IKsiSignature Extend(CalendarHashChain calendarHashChain, PublicationRecordInSignature publicationRecord, IKsiSignatureFactory signatureFactory = null)
{
Logger.Debug("Extending KSI signature.");
if (calendarHashChain == null)
{
throw new ArgumentNullException(nameof(calendarHashChain));
}
if (CalendarHashChain != null && !CalendarHashChain.AreRightLinksEqual(calendarHashChain))
{
throw new KsiException("Right links of signature calendar hash chain and extended calendar hash chain do not match");
}
if (publicationRecord == null)
{
publicationRecord = new PublicationRecordInSignature(false, false, calendarHashChain.PublicationData);
}
if (signatureFactory == null)
{
signatureFactory = new KsiSignatureFactory();
}
using (TlvWriter writer = new TlvWriter(new MemoryStream()))
{
foreach (ITlvTag childTag in this)
{
switch (childTag.Type)
{
case Constants.CalendarHashChain.TagType:
case Constants.CalendarAuthenticationRecord.TagType:
case Constants.PublicationRecord.TagTypeInSignature:
break;
default:
writer.WriteTag(childTag);
break;
}
}
writer.WriteTag(calendarHashChain);
writer.WriteTag(publicationRecord);
try
{
IKsiSignature signature = signatureFactory.CreateByContent(((MemoryStream)writer.BaseStream).ToArray(), InputHash);
Logger.Debug("Extending KSI signature successful.");
return(signature);
}
catch (TlvException e)
{
Logger.Warn("Extending KSI signature failed: {0}", e);
throw;
}
}
}
/// <summary>
/// Extend signature to publication.
/// </summary>
/// <param name="signature">KSI signature</param>
/// <param name="publicationData">publication data</param>
/// <returns>extended KSI signature</returns>
public IKsiSignature Extend(IKsiSignature signature, PublicationData publicationData)
{
if (publicationData == null)
{
throw new ArgumentNullException(nameof(publicationData));
}
return(Extend(signature, new PublicationRecordInSignature(false, false, publicationData)));
}
public void ExtendToOtherExtendedSignatureAndVerifyWithUserProvidedPublication(Ksi ksi)
{
IKsiSignature ksiSignatureToExtend = TestUtil.GetSignature();
IKsiSignature ksiSignatureForPublicationRecord = TestUtil.GetSignature(Resources.KsiSignature_Ok_Extended);
IKsiSignature extendedSignature = ksi.Extend(ksiSignatureToExtend, ksiSignatureForPublicationRecord.PublicationRecord);
Assert.AreEqual(ksiSignatureForPublicationRecord.PublicationRecord.PublicationData.PublicationHash,
extendedSignature.PublicationRecord.PublicationData.PublicationHash);
}
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);
}
/// <summary>
/// Extend signature to publication.
/// </summary>
/// <param name="signature">KSI signature</param>
/// <param name="publicationRecord">publication</param>
/// <returns>extended KSI signature</returns>
public IKsiSignature Extend(IKsiSignature signature, PublicationRecordInPublicationFile publicationRecord)
{
if (publicationRecord == null)
{
throw new ArgumentNullException(nameof(publicationRecord));
}
return(Extend(signature, publicationRecord.ConvertToPublicationRecordInSignature()));
}
/// <summary>
/// Create new verification context instance.
/// </summary>
/// <param name="signature">KSI signature</param>
public VerificationContext(IKsiSignature signature)
{
if (signature == null)
{
throw new ArgumentNullException(nameof(signature));
}
Signature = signature;
}
public void PrintAggregationHashChain()
{
IKsiSignature signature = LoadExtendedSignature();
foreach (AggregationHashChain ahc in signature.GetAggregationHashChains())
{
Console.WriteLine("PrintAggregationHashChain > chain identity > " + ahc.GetChainIdentity());
}
}
