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()); } }