diff --git a/crypto/test/src/tsp/test/AllTests.cs b/crypto/test/src/tsp/test/AllTests.cs
new file mode 100644
index 000000000..66dc9c480
--- /dev/null
+++ b/crypto/test/src/tsp/test/AllTests.cs
@@ -0,0 +1,32 @@
+using System;
+
+using NUnit.Core;
+using NUnit.Framework;
+
+using Org.BouncyCastle.Utilities.Test;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ public class AllTests
+ {
+ public static void Main(
+ string[] args)
+ {
+ //junit.textui.TestRunner.run(suite());
+ EventListener el = new NullListener();
+ suite().Run(el);
+ }
+
+ public static TestSuite suite()
+ {
+ TestSuite suite = new TestSuite("TSP Tests");
+
+ suite.Add(new GenTimeAccuracyUnitTest());
+ suite.Add(new ParseTest());
+ suite.Add(new TimeStampTokenInfoUnitTest());
+ suite.Add(new TspTest());
+
+ return suite;
+ }
+ }
+}
diff --git a/crypto/test/src/tsp/test/GenTimeAccuracyTest.cs b/crypto/test/src/tsp/test/GenTimeAccuracyTest.cs
new file mode 100644
index 000000000..01cc83d53
--- /dev/null
+++ b/crypto/test/src/tsp/test/GenTimeAccuracyTest.cs
@@ -0,0 +1,116 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1;
+using Org.BouncyCastle.Asn1.Tsp;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ [TestFixture]
+ public class GenTimeAccuracyUnitTest
+ {
+ private static readonly DerInteger ZERO_VALUE = new DerInteger(0);
+ private static readonly DerInteger ONE_VALUE = new DerInteger(1);
+ private static readonly DerInteger TWO_VALUE = new DerInteger(2);
+ private static readonly DerInteger THREE_VALUE = new DerInteger(3);
+
+ [Test]
+ public void TestOneTwoThree()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(ONE_VALUE, TWO_VALUE, THREE_VALUE));
+
+ checkValues(accuracy, ONE_VALUE, TWO_VALUE, THREE_VALUE);
+
+ checkTostring(accuracy, "1.002003");
+ }
+
+ [Test]
+ public void TestThreeTwoOne()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(THREE_VALUE, TWO_VALUE, ONE_VALUE));
+
+ checkValues(accuracy, THREE_VALUE, TWO_VALUE, ONE_VALUE);
+
+ checkTostring(accuracy, "3.002001");
+ }
+
+ [Test]
+ public void TestTwoThreeTwo()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(TWO_VALUE, THREE_VALUE, TWO_VALUE));
+
+ checkValues(accuracy, TWO_VALUE, THREE_VALUE, TWO_VALUE);
+
+ checkTostring(accuracy, "2.003002");
+ }
+
+ [Test]
+ public void TestZeroTwoThree()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(ZERO_VALUE, TWO_VALUE, THREE_VALUE));
+
+ checkValues(accuracy, ZERO_VALUE, TWO_VALUE, THREE_VALUE);
+
+ checkTostring(accuracy, "0.002003");
+ }
+
+ [Test]
+ public void TestThreeTwoNull()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(THREE_VALUE, TWO_VALUE, null));
+
+ checkValues(accuracy, THREE_VALUE, TWO_VALUE, ZERO_VALUE);
+
+ checkTostring(accuracy, "3.002000");
+ }
+
+ [Test]
+ public void TestOneNullOne()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(ONE_VALUE, null, ONE_VALUE));
+
+ checkValues(accuracy, ONE_VALUE, ZERO_VALUE, ONE_VALUE);
+
+ checkTostring(accuracy, "1.000001");
+ }
+
+ [Test]
+ public void TestZeroNullNull()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(ZERO_VALUE, null, null));
+
+ checkValues(accuracy, ZERO_VALUE, ZERO_VALUE, ZERO_VALUE);
+
+ checkTostring(accuracy, "0.000000");
+ }
+
+ [Test]
+ public void TestNullNullNull()
+ {
+ GenTimeAccuracy accuracy = new GenTimeAccuracy(new Accuracy(null, null, null));
+
+ checkValues(accuracy, ZERO_VALUE, ZERO_VALUE, ZERO_VALUE);
+
+ checkTostring(accuracy, "0.000000");
+ }
+
+ private void checkValues(
+ GenTimeAccuracy accuracy,
+ DerInteger secs,
+ DerInteger millis,
+ DerInteger micros)
+ {
+ Assert.AreEqual(secs.Value.IntValue, accuracy.Seconds);
+ Assert.AreEqual(millis.Value.IntValue, accuracy.Millis);
+ Assert.AreEqual(micros.Value.IntValue, accuracy.Micros);
+ }
+
+ private void checkTostring(
+ GenTimeAccuracy accuracy,
+ string expected)
+ {
+ Assert.AreEqual(expected, accuracy.ToString());
+ }
+ }
+}
diff --git a/crypto/test/src/tsp/test/ParseTest.cs b/crypto/test/src/tsp/test/ParseTest.cs
new file mode 100644
index 000000000..ec9ba72f6
--- /dev/null
+++ b/crypto/test/src/tsp/test/ParseTest.cs
@@ -0,0 +1,396 @@
+using System;
+using System.Collections;
+using System.IO;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Cmp;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.X509;
+using Org.BouncyCastle.X509.Store;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ [TestFixture]
+ public class ParseTest
+ {
+ private static readonly byte[] sha1Request = Base64.Decode("MDACAQEwITAJBgUrDgMCGgUABBT5UbEBmJssO3RxcQtOePxNvfoMpgIIC+GvYW2mtZQ=");
+ private static readonly byte[] sha1noNonse = Base64.Decode("MCYCAQEwITAJBgUrDgMCGgUABBT5UbEBmJssO3RxcQtOePxNvfoMpg==");
+ private static readonly byte[] md5Request = Base64.Decode("MDoCAQEwIDAMBggqhkiG9w0CBQUABBDIl9FBCvjyx0+6EbHbUR6eBgkrBgEEAakHBQECCDQluayIxIzn");
+ private static readonly byte[] ripemd160Request = Base64.Decode("MD8CAQEwITAJBgUrJAMCAQUABBSq03a/mk50Yd9lMF+BSqOp/RHGQQYJKwYBBAGpBwUBAgkA4SZs9NfqISMBAf8=");
+
+ private static readonly byte[] sha1Response = Base64.Decode(
+ "MIICbDADAgEAMIICYwYJKoZIhvcNAQcCoIICVDCCAlACAQMxCzAJBgUrDgMC"
+ + "GgUAMIHaBgsqhkiG9w0BCRABBKCBygSBxzCBxAIBAQYEKgMEATAhMAkGBSsO"
+ + "AwIaBQAEFPlRsQGYmyw7dHFxC054/E29+gymAgEEGA8yMDA0MTIwOTA3NTIw"
+ + "NVowCgIBAYACAfSBAWQBAf8CCAvhr2FtprWUoGmkZzBlMRgwFgYDVQQDEw9F"
+ + "cmljIEguIEVjaGlkbmExJDAiBgkqhkiG9w0BCQEWFWVyaWNAYm91bmN5Y2Fz"
+ + "dGxlLm9yZzEWMBQGA1UEChMNQm91bmN5IENhc3RsZTELMAkGA1UEBhMCQVUx"
+ + "ggFfMIIBWwIBATAqMCUxFjAUBgNVBAoTDUJvdW5jeSBDYXN0bGUxCzAJBgNV"
+ + "BAYTAkFVAgECMAkGBSsOAwIaBQCggYwwGgYJKoZIhvcNAQkDMQ0GCyqGSIb3"
+ + "DQEJEAEEMBwGCSqGSIb3DQEJBTEPFw0wNDEyMDkwNzUyMDVaMCMGCSqGSIb3"
+ + "DQEJBDEWBBTGR1cbm94tWbcpDWrH+bD8UYePsTArBgsqhkiG9w0BCRACDDEc"
+ + "MBowGDAWBBS37aLzFcheqeJ5cla0gjNWHGKbRzANBgkqhkiG9w0BAQEFAASB"
+ + "gBrc9CJ3xlcTQuWQXJUqPEn6f6vfJAINKsn22z8LIfS/2p/CTFU6+W/bz8j8"
+ + "j+8uWEJe8okTsI0FflljIsspqOPTB/RrnXteajbkuk/rLmz1B2g/qWBGAzPI"
+ + "D214raBc1a7Bpd76PkvSSdjqrEaaskd+7JJiPr9l9yeSoh1AIt0N");
+
+ private static readonly byte[] sha1noNonseResponse = Base64.Decode(
+ "MIICYjADAgEAMIICWQYJKoZIhvcNAQcCoIICSjCCAkYCAQMxCzAJBgUrDgMC"
+ + "GgUAMIHQBgsqhkiG9w0BCRABBKCBwASBvTCBugIBAQYEKgMEATAhMAkGBSsO"
+ + "AwIaBQAEFPlRsQGYmyw7dHFxC054/E29+gymAgECGA8yMDA0MTIwOTA3MzQx"
+ + "MlowCgIBAYACAfSBAWQBAf+gaaRnMGUxGDAWBgNVBAMTD0VyaWMgSC4gRWNo"
+ + "aWRuYTEkMCIGCSqGSIb3DQEJARYVZXJpY0Bib3VuY3ljYXN0bGUub3JnMRYw"
+ + "FAYDVQQKEw1Cb3VuY3kgQ2FzdGxlMQswCQYDVQQGEwJBVTGCAV8wggFbAgEB"
+ + "MCowJTEWMBQGA1UEChMNQm91bmN5IENhc3RsZTELMAkGA1UEBhMCQVUCAQIw"
+ + "CQYFKw4DAhoFAKCBjDAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJ"
+ + "KoZIhvcNAQkFMQ8XDTA0MTIwOTA3MzQxMlowIwYJKoZIhvcNAQkEMRYEFMNA"
+ + "xlscHYiByHL9DIEh3FewIhgSMCsGCyqGSIb3DQEJEAIMMRwwGjAYMBYEFLft"
+ + "ovMVyF6p4nlyVrSCM1YcYptHMA0GCSqGSIb3DQEBAQUABIGAaj46Tarrg7V7"
+ + "z13bbetrGv+xy159eE8kmIW9nPegru3DuK/GmbMx9W3l0ydx0zdXRwYi6NZc"
+ + "nNqbEZQZ2L1biJVTflgWq4Nxu4gPGjH/BGHKdH/LyW4eDcXZR39AkNBMnDAK"
+ + "EmhhJo1/Tc+S/WkV9lnHJCPIn+TAijBUO6EiTik=");
+
+ private static readonly byte[] md5Response = Base64.Decode(
+ "MIICcDADAgEAMIICZwYJKoZIhvcNAQcCoIICWDCCAlQCAQMxCzAJBgUrDgMC"
+ + "GgUAMIHeBgsqhkiG9w0BCRABBKCBzgSByzCByAIBAQYJKwYBBAGpBwUBMCAw"
+ + "DAYIKoZIhvcNAgUFAAQQyJfRQQr48sdPuhGx21EengIBAxgPMjAwNDEyMDkw"
+ + "NzQ2MTZaMAoCAQGAAgH0gQFkAQH/Agg0JbmsiMSM56BppGcwZTEYMBYGA1UE"
+ + "AxMPRXJpYyBILiBFY2hpZG5hMSQwIgYJKoZIhvcNAQkBFhVlcmljQGJvdW5j"
+ + "eWNhc3RsZS5vcmcxFjAUBgNVBAoTDUJvdW5jeSBDYXN0bGUxCzAJBgNVBAYT"
+ + "AkFVMYIBXzCCAVsCAQEwKjAlMRYwFAYDVQQKEw1Cb3VuY3kgQ2FzdGxlMQsw"
+ + "CQYDVQQGEwJBVQIBAjAJBgUrDgMCGgUAoIGMMBoGCSqGSIb3DQEJAzENBgsq"
+ + "hkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMDQxMjA5MDc0NjE2WjAjBgkq"
+ + "hkiG9w0BCQQxFgQUFpRpaiRUUjiY7EbefbWLKDIY0XMwKwYLKoZIhvcNAQkQ"
+ + "AgwxHDAaMBgwFgQUt+2i8xXIXqnieXJWtIIzVhxim0cwDQYJKoZIhvcNAQEB"
+ + "BQAEgYBTwKsLLrQm+bvKV7Jwto/cMQh0KsVB5RoEeGn5CI9XyF2Bm+JRcvQL"
+ + "Nm7SgSOBVt4A90TqujxirNeyQnXRiSnFvXd09Wet9WIQNpwpiGlE7lCrAhuq"
+ + "/TAUe79VIpoQZDtyhbh0Vzxl24yRoechabC0zuPpOWOzrA4YC3Hv1J2tAA==");
+
+ private static readonly byte[] signingCert = Base64.Decode(
+ "MIICWjCCAcOgAwIBAgIBAjANBgkqhkiG9w0BAQQFADAlMRYwFAYDVQQKEw1Cb3Vu"
+ + "Y3kgQ2FzdGxlMQswCQYDVQQGEwJBVTAeFw0wNDEyMDkwNzEzMTRaFw0wNTAzMTkw"
+ + "NzEzMTRaMGUxGDAWBgNVBAMTD0VyaWMgSC4gRWNoaWRuYTEkMCIGCSqGSIb3DQEJ"
+ + "ARYVZXJpY0Bib3VuY3ljYXN0bGUub3JnMRYwFAYDVQQKEw1Cb3VuY3kgQ2FzdGxl"
+ + "MQswCQYDVQQGEwJBVTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAqGAFO3dK"
+ + "jB7Ca7u5Z3CabsbGr2Exg+3sztSPiRCIba03es4295EhtDF5bXQvrW2R1Bg72vED"
+ + "5tWaQjVDetvDfCzVC3ErHLTVk3OgpLIP1gf2T0LcOH2pTh2LP9c5Ceta+uggK8zK"
+ + "9sYUUnzGPSAZxrqHIIAlPIgqk0BMV+KApyECAwEAAaNaMFgwHQYDVR0OBBYEFO4F"
+ + "YoqogtB9MjD0NB5x5HN3TrGUMB8GA1UdIwQYMBaAFPXAecuwLqNkCxYVLE/ngFQR"
+ + "7RLIMBYGA1UdJQEB/wQMMAoGCCsGAQUFBwMIMA0GCSqGSIb3DQEBBAUAA4GBADGi"
+ + "D5/qmGvcBgswEM/z2dF4lOxbTNKUW31ZHiU8CXlN0IkFtNbBLBTbJOQIAUnNEabL"
+ + "T7aYgj813OZKUbJTx4MuGChhot/TEP7hKo/xz9OnXLsqYDKbqbo8iLOode+SI7II"
+ + "+yYghOtqvx32cL2Qmffi1LaMbhJP+8NbsIxowdRC");
+
+ private static readonly byte[] unacceptablePolicy = Base64.Decode(
+ "MDAwLgIBAjAkDCJSZXF1ZXN0ZWQgcG9saWN5IGlzIG5vdCBzdXBwb3J0ZWQuAwMAAAE=");
+
+ private static readonly byte[] generalizedTime = Base64.Decode(
+ "MIIKPTADAgEAMIIKNAYJKoZIhvcNAQcCoIIKJTCCCiECAQMxCzAJBgUrDgMC"
+ + "GgUAMIIBGwYLKoZIhvcNAQkQAQSgggEKBIIBBjCCAQICAQEGCisGAQQBhFkK"
+ + "AwEwITAJBgUrDgMCGgUABBQAAAAAAAAAAAAAAAAAAAAAAAAAAAICUC8YEzIw"
+ + "MDUwMzEwMTA1ODQzLjkzM1owBIACAfQBAf8CAWSggaikgaUwgaIxCzAJBgNV"
+ + "BAYTAkdCMRcwFQYDVQQIEw5DYW1icmlkZ2VzaGlyZTESMBAGA1UEBxMJQ2Ft"
+ + "YnJpZGdlMSQwIgYDVQQKExtuQ2lwaGVyIENvcnBvcmF0aW9uIExpbWl0ZWQx"
+ + "JzAlBgNVBAsTHm5DaXBoZXIgRFNFIEVTTjozMjJBLUI1REQtNzI1QjEXMBUG"
+ + "A1UEAxMOZGVtby1kc2UyMDAtMDGgggaFMIID2TCCA0KgAwIBAgICAIswDQYJ"
+ + "KoZIhvcNAQEFBQAwgYwxCzAJBgNVBAYTAkdCMRcwFQYDVQQIEw5DYW1icmlk"
+ + "Z2VzaGlyZTESMBAGA1UEBxMJQ2FtYnJpZGdlMSQwIgYDVQQKExtuQ2lwaGVy"
+ + "IENvcnBvcmF0aW9uIExpbWl0ZWQxGDAWBgNVBAsTD1Byb2R1Y3Rpb24gVEVT"
+ + "VDEQMA4GA1UEAxMHVEVTVCBDQTAeFw0wNDA2MTQxNDIzNTlaFw0wNTA2MTQx"
+ + "NDIzNTlaMIGiMQswCQYDVQQGEwJHQjEXMBUGA1UECBMOQ2FtYnJpZGdlc2hp"
+ + "cmUxEjAQBgNVBAcTCUNhbWJyaWRnZTEkMCIGA1UEChMbbkNpcGhlciBDb3Jw"
+ + "b3JhdGlvbiBMaW1pdGVkMScwJQYDVQQLEx5uQ2lwaGVyIERTRSBFU046MzIy"
+ + "QS1CNURELTcyNUIxFzAVBgNVBAMTDmRlbW8tZHNlMjAwLTAxMIGfMA0GCSqG"
+ + "SIb3DQEBAQUAA4GNADCBiQKBgQC7zUamCeLIApddx1etW5YEFrL1WXnlCd7j"
+ + "mMFI6RpSq056LBkF1z5LgucLY+e/c3u2Nw+XJuS3a2fKuBD7I1s/6IkVtIb/"
+ + "KLDjjafOnottKhprH8K41siJUeuK3PRzfZ5kF0vwB3rNvWPCBJmp7kHtUQw3"
+ + "RhIsJTYs7Wy8oVFHVwIDAQABo4IBMDCCASwwCQYDVR0TBAIwADAWBgNVHSUB"
+ + "Af8EDDAKBggrBgEFBQcDCDAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5l"
+ + "cmF0ZWQgQ2VydGlmaWNhdGUwHQYDVR0OBBYEFDlEe9Pd0WwQrtnEmFRI2Vmt"
+ + "b+lCMIG5BgNVHSMEgbEwga6AFNy1VPweOQLC65bs6/0RcUYB19vJoYGSpIGP"
+ + "MIGMMQswCQYDVQQGEwJHQjEXMBUGA1UECBMOQ2FtYnJpZGdlc2hpcmUxEjAQ"
+ + "BgNVBAcTCUNhbWJyaWRnZTEkMCIGA1UEChMbbkNpcGhlciBDb3Jwb3JhdGlv"
+ + "biBMaW1pdGVkMRgwFgYDVQQLEw9Qcm9kdWN0aW9uIFRFU1QxEDAOBgNVBAMT"
+ + "B1RFU1QgQ0GCAQAwDQYJKoZIhvcNAQEFBQADgYEASEMlrpRE1RYZPxP3530e"
+ + "hOYUDjgQbw0dwpPjQtLWkeJrePMzDBAbuWwpRI8dOzKP3Rnrm5rxJ7oLY2S0"
+ + "A9ZfV+iwFKagEHFytfnPm2Y9AeNR7a3ladKd7NFMw+5Tbk7Asbetbb+NJfCl"
+ + "9YzHwxLGiQbpKxgc+zYOjq74eGLKtcKhggKkMIICDQIBATCB0qGBqKSBpTCB"
+ + "ojELMAkGA1UEBhMCR0IxFzAVBgNVBAgTDkNhbWJyaWRnZXNoaXJlMRIwEAYD"
+ + "VQQHEwlDYW1icmlkZ2UxJDAiBgNVBAoTG25DaXBoZXIgQ29ycG9yYXRpb24g"
+ + "TGltaXRlZDEnMCUGA1UECxMebkNpcGhlciBEU0UgRVNOOjMyMkEtQjVERC03"
+ + "MjVCMRcwFQYDVQQDEw5kZW1vLWRzZTIwMC0wMaIlCgEBMAkGBSsOAwIaBQAD"
+ + "FQDaLe88TQvM+iMKmIXMmDSyPCZ/+KBmMGSkYjBgMQswCQYDVQQGEwJVUzEk"
+ + "MCIGA1UEChMbbkNpcGhlciBDb3Jwb3JhdGlvbiBMaW1pdGVkMRgwFgYDVQQL"
+ + "Ew9Qcm9kdWN0aW9uIFRlc3QxETAPBgNVBAMTCFRlc3QgVE1DMA0GCSqGSIb3"
+ + "DQEBBQUAAgjF2jVbAAAAADAiGA8yMDA1MDMxMDAyNTQxOVoYDzIwMDUwMzEz"
+ + "MDI1NDE5WjCBjTBLBgorBgEEAYRZCgQBMT0wOzAMAgTF2jVbAgQAAAAAMA8C"
+ + "BAAAAAACBAAAaLkCAf8wDAIEAAAAAAIEAAKV/DAMAgTF3inbAgQAAAAAMD4G"
+ + "CisGAQQBhFkKBAIxMDAuMAwGCisGAQQBhFkKAwGgDjAMAgQAAAAAAgQAB6Eg"
+ + "oQ4wDAIEAAAAAAIEAAPQkDANBgkqhkiG9w0BAQUFAAOBgQB1q4d3GNWk7oAT"
+ + "WkpYmZaTFvapMhTwAmAtSGgFmNOZhs21iHWl/X990/HEBsduwxohfrd8Pz64"
+ + "hV/a76rpeJCVUfUNmbRIrsurFx6uKwe2HUHKW8grZWeCD1L8Y1pKQdrD41gu"
+ + "v0msfOXzLWW+xe5BcJguKclN8HmT7s2odtgiMTGCAmUwggJhAgEBMIGTMIGM"
+ + "MQswCQYDVQQGEwJHQjEXMBUGA1UECBMOQ2FtYnJpZGdlc2hpcmUxEjAQBgNV"
+ + "BAcTCUNhbWJyaWRnZTEkMCIGA1UEChMbbkNpcGhlciBDb3Jwb3JhdGlvbiBM"
+ + "aW1pdGVkMRgwFgYDVQQLEw9Qcm9kdWN0aW9uIFRFU1QxEDAOBgNVBAMTB1RF"
+ + "U1QgQ0ECAgCLMAkGBSsOAwIaBQCgggEnMBoGCSqGSIb3DQEJAzENBgsqhkiG"
+ + "9w0BCRABBDAjBgkqhkiG9w0BCQQxFgQUi1iYx5H3ACnvngWZTPfdxGswkSkw"
+ + "geMGCyqGSIb3DQEJEAIMMYHTMIHQMIHNMIGyBBTaLe88TQvM+iMKmIXMmDSy"
+ + "PCZ/+DCBmTCBkqSBjzCBjDELMAkGA1UEBhMCR0IxFzAVBgNVBAgTDkNhbWJy"
+ + "aWRnZXNoaXJlMRIwEAYDVQQHEwlDYW1icmlkZ2UxJDAiBgNVBAoTG25DaXBo"
+ + "ZXIgQ29ycG9yYXRpb24gTGltaXRlZDEYMBYGA1UECxMPUHJvZHVjdGlvbiBU"
+ + "RVNUMRAwDgYDVQQDEwdURVNUIENBAgIAizAWBBSpS/lH6bN/wf3E2z2X29vF"
+ + "2U7YHTANBgkqhkiG9w0BAQUFAASBgGvDVsgsG5I5WKjEDVHvdRwUx+8Cp10l"
+ + "zGF8o1h7aK5O3zQ4jLayYHea54E5+df35gG7Z3eoOy8E350J7BvHiwDLTqe8"
+ + "SoRlGs9VhL6LMmCcERfGSlSn61Aa15iXZ8eHMSc5JTeJl+kqy4I3FPP4m2ai"
+ + "8wy2fQhn7hUM8Ntg7Y2s");
+
+ private static readonly byte[] v2SigningCertResponse = Base64.Decode(
+ "MIIPPTADAgEAMIIPNAYJKoZIhvcNAQcCoIIPJTCCDyECAQMxDzANBglghkgBZQMEAgEFADCB6QYL"
+ + "KoZIhvcNAQkQAQSggdkEgdYwgdMCAQEGBgQAj2cBATAxMA0GCWCGSAFlAwQCAQUABCBcU0GN08TA"
+ + "LUFi7AAwQwVkSXqGu9tAzvJ7EXW7SMXHHQIRAM7Fa7g6tMvZI3dgllwMfpcYDzIwMDcxMjExMTAy"
+ + "MTU5WjADAgEBAgYBFsi5OlmgYqRgMF4xCzAJBgNVBAYTAkRFMSQwIgYDVQQKDBtEZXV0c2NoZSBS"
+ + "ZW50ZW52ZXJzaWNoZXJ1bmcxEzARBgNVBAsMClFDIFJvb3QgQ0ExFDASBgNVBAMMC1FDIFJvb3Qg"
+ + "VFNQoIILQjCCBwkwggXxoAMCAQICAwN1pjANBgkqhkiG9w0BAQsFADBIMQswCQYDVQQGEwJERTEk"
+ + "MCIGA1UECgwbRGV1dHNjaGUgUmVudGVudmVyc2ljaGVydW5nMRMwEQYDVQQLDApRQyBSb290IENB"
+ + "MB4XDTA3MTEyMDE2MDcyMFoXDTEyMDcyNzIwMjExMVowXjELMAkGA1UEBhMCREUxJDAiBgNVBAoM"
+ + "G0RldXRzY2hlIFJlbnRlbnZlcnNpY2hlcnVuZzETMBEGA1UECwwKUUMgUm9vdCBDQTEUMBIGA1UE"
+ + "AwwLUUMgUm9vdCBUU1AwggEkMA0GCSqGSIb3DQEBAQUAA4IBEQAwggEMAoIBAQCv1vO+EtGnJNs0"
+ + "atv76BAJXs4bmO8yzVwe3RUtgeu5z9iefh8P46i1g3EL2CD15NcTfoHksr5KudNY30olfjHG7lIu"
+ + "MO3R5sAcrGDPP7riZJnaI6VD/e6kVR569VBid5z105fJAB7mID7+Bn7pdRwDW3Fy2CzfofXGuvrO"
+ + "GPNEWq8x8kqqf75DB5nAs5QP8H41obkdkap2ttHkkPZCiMghTs8iHfpJ0STn47MKq+QrUmuATMZi"
+ + "XrdEfb7f3TBMjO0UVJF64Mh+kC9GtUEHlcm0Tq2Pk5XIUxWEyL94rZ4UWcVdSVE7IjggV2MifMNx"
+ + "geZO3SwsDZk71AhDBy30CSzBAgUAx3HB5aOCA+IwggPeMBYGA1UdJQEB/wQMMAoGCCsGAQUFBwMI"
+ + "MBMGA1UdIwQMMAqACECefuBmflfeMBgGCCsGAQUFBwEDBAwwCjAIBgYEAI5GAQEwUAYIKwYBBQUH"
+ + "AQEERDBCMEAGCCsGAQUFBzABhjRodHRwOi8vb2NzcC1yb290cWMudGMuZGV1dHNjaGUtcmVudGVu"
+ + "dmVyc2ljaGVydW5nLmRlMHcGA1UdIARwMG4wbAYNKwYBBAGBrTwBCAEBAzBbMFkGCCsGAQUFBwIB"
+ + "Fk1odHRwOi8vd3d3LmRldXRzY2hlLXJlbnRlbnZlcnNpY2hlcnVuZy1idW5kLmRlL3N0YXRpYy90"
+ + "cnVzdGNlbnRlci9wb2xpY3kuaHRtbDCCATwGA1UdHwSCATMwggEvMHygeqB4hnZsZGFwOi8vZGly"
+ + "LnRjLmRldXRzY2hlLXJlbnRlbnZlcnNpY2hlcnVuZy5kZS9vdT1RQyUyMFJvb3QlMjBDQSxjbj1Q"
+ + "dWJsaWMsbz1EUlYsYz1ERT9hdHRybmFtZT1jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0MIGuoIGr"
+ + "oIGohoGlaHR0cDovL2Rpci50Yy5kZXV0c2NoZS1yZW50ZW52ZXJzaWNoZXJ1bmcuZGU6ODA4OS9z"
+ + "ZXJ2bGV0L0Rpclh3ZWIvQ2EveC5jcmw/ZG49b3UlM0RRQyUyMFJvb3QlMjBDQSUyQ2NuJTNEUHVi"
+ + "bGljJTJDbyUzRERSViUyQ2MlM0RERSZhdHRybmFtZT1jZXJ0aWZpY2F0ZVJldm9jYXRpb25MaXN0"
+ + "MIIBLQYDVR0SBIIBJDCCASCGdGxkYXA6Ly9kaXIudGMuZGV1dHNjaGUtcmVudGVudmVyc2ljaGVy"
+ + "dW5nLmRlL2NuPTE0NTUxOCxvdT1RQyUyMFJvb3QlMjBDQSxjbj1QdWJsaWMsbz1EUlYsYz1ERT9h"
+ + "dHRybmFtZT1jQUNlcnRpZmljYXRlhoGnaHR0cDovL2Rpci50Yy5kZXV0c2NoZS1yZW50ZW52ZXJz"
+ + "aWNoZXJ1bmcuZGU6ODA4OS9zZXJ2bGV0L0Rpclh3ZWIvQ2EveC5jZXI/ZG49Y24lM0QxNDU1MTgl"
+ + "MkNvdSUzRFFDJTIwUm9vdCUyMENBJTJDY24lM0RQdWJsaWMlMkNvJTNERFJWJTJDYyUzRERFJmF0"
+ + "dHJuYW1lPWNBQ2VydGlmaWNhdGUwDgYDVR0PAQH/BAQDAgZAMDsGA1UdCQQ0MDIwMAYDVQQDMSkT"
+ + "J1FDIFRTUCBEZXV0c2NoZSBSZW50ZW52ZXJzaWNoZXJ1bmcgMTpQTjAMBgNVHRMBAf8EAjAAMA0G"
+ + "CSqGSIb3DQEBCwUAA4IBAQCCrWe3Pd3ioX7d8phXvVAa859Rvgf0k3pZ6R4GMj8h/k6MNjNIrdAs"
+ + "wgUVkBbXMLLBk0smsvTdFIVtTBdp1urb9l7vXjDA4MckXBOXPcz4fN8Oswk92d+fM9XU1jKVPsFG"
+ + "PV6j8lAqfq5jwaRxOnS96UBGLKG+NdcrEyiMp/ZkpqnEQZZfu2mkeq6CPahnbBTZqsE0jgY351gU"
+ + "9T6SFVvLIFH7cOxJqsoxPqv5YEcgiXPpOyyu2rpQqKYBYcnerF6/zx5hmWHxTd7MWaTHm0gJI/Im"
+ + "d8esbW+xyaJuAVUcBA+sDmSe8AAoRVxwBRY+xi9ApaJHpmwT+0n2K2GsL3wIMIIEMTCCAxmgAwIB"
+ + "AgIDAjhuMA0GCSqGSIb3DQEBCwUAMEgxCzAJBgNVBAYTAkRFMSQwIgYDVQQKDBtEZXV0c2NoZSBS"
+ + "ZW50ZW52ZXJzaWNoZXJ1bmcxEzARBgNVBAsMClFDIFJvb3QgQ0EwHhcNMDcwNzI3MjAyMTExWhcN"
+ + "MTIwNzI3MjAyMTExWjBIMQswCQYDVQQGEwJERTEkMCIGA1UECgwbRGV1dHNjaGUgUmVudGVudmVy"
+ + "c2ljaGVydW5nMRMwEQYDVQQLDApRQyBSb290IENBMIIBJDANBgkqhkiG9w0BAQEFAAOCAREAMIIB"
+ + "DAKCAQEAzuhBdo9c84DdzsggjWOgfC4jJ2jYqpsOpBo3DVyem+5R26QK4feZdyFnaGvyG+TLcdLO"
+ + "iCecGmrRGD+ey4IhjCONb7hsQQhJWTyDEtBblzYB0yjY8+9fnNeR61W+M/KlMgC6Rw/w+zwzklTM"
+ + "MWwIbxLHm8l9jTSKFjAWTwjE8bCzpUCwN8+4JbFTwjwOJ5lsVA5Xa34wpgr6lgL3WrVTV1NSprqR"
+ + "ZYDWg477tht0KkyOJt3guF3RONKBBuTO2qCbpUeI8m4v3tznoopYbV5Gp5wu5gqd6lTfgju3ldql"
+ + "bxtuCLZd0nAI5rLEOPItDKl4vPXllmmtGIrtDZlwr86cbwIFAJvMJpGjggEgMIIBHDAPBgNVHRMB"
+ + "Af8EBTADAQH/MBEGA1UdDgQKBAhAnn7gZn5X3jB3BgNVHSAEcDBuMGwGDSsGAQQBga08AQgBAQEw"
+ + "WzBZBggrBgEFBQcCARZNaHR0cDovL3d3dy5kZXV0c2NoZS1yZW50ZW52ZXJzaWNoZXJ1bmctYnVu"
+ + "ZC5kZS9zdGF0aWMvdHJ1c3RjZW50ZXIvcG9saWN5Lmh0bWwwUwYDVR0JBEwwSjBIBgNVBAMxQRM/"
+ + "UUMgV3VyemVsemVydGlmaXppZXJ1bmdzc3RlbGxlIERldXRzY2hlIFJlbnRlbnZlcnNpY2hlcnVu"
+ + "ZyAxOlBOMBgGCCsGAQUFBwEDBAwwCjAIBgYEAI5GAQEwDgYDVR0PAQH/BAQDAgIEMA0GCSqGSIb3"
+ + "DQEBCwUAA4IBAQBNGs7Dnc1yzzpZrkuC+oLv+NhbORTEYNgpaOetB1JQ1EbUBoPuNN4ih0ngy/uJ"
+ + "D2O+h4JsNkmELgaehLWyFwATqCYZY4cTAGVoEwgn93x3aW8JbMDQf+YEJDSDsXcm4oIDFPqv5M6o"
+ + "HZUWfsPka3mxKivfKtWhooTz1/+BEGReVQ2oOAvlwXlkEab9e3GOqXQUcLPYDTl8BQxiYhtQtf3d"
+ + "kORiUkuGiGX1YJ5JnZnG3ElMjPgOl8rOiYU7oj9uv1HVb5sdAwuVw0BR/eiMVDBT8DNyfoJmPeQQ"
+ + "A9pXtoAYO0Ya7wNNmCY2Y63YfBlRCF+9VQv2RZ4TdO1KGWwxR98OMYIC1zCCAtMCAQEwTzBIMQsw"
+ + "CQYDVQQGEwJERTEkMCIGA1UECgwbRGV1dHNjaGUgUmVudGVudmVyc2ljaGVydW5nMRMwEQYDVQQL"
+ + "DApRQyBSb290IENBAgMDdaYwDQYJYIZIAWUDBAIBBQCgggFZMBoGCSqGSIb3DQEJAzENBgsqhkiG"
+ + "9w0BCRABBDAvBgkqhkiG9w0BCQQxIgQgO7FFODWWwF5RUjo6wjIkgkD5u7dH+NICiCpSgRRqd/Aw"
+ + "ggEIBgsqhkiG9w0BCRACLzGB+DCB9TCB8jB3BCAMMZqK/5pZxOb3ruCbcgxStaTDwDHaf2glEo6P"
+ + "+89t8TBTMEykSjBIMQswCQYDVQQGEwJERTEkMCIGA1UECgwbRGV1dHNjaGUgUmVudGVudmVyc2lj"
+ + "aGVydW5nMRMwEQYDVQQLDApRQyBSb290IENBAgMDdaYwdwQgl7vwI+P47kpxhWLoIdEco7UfGwZ2"
+ + "X4el3jaZ67q5/9IwUzBMpEowSDELMAkGA1UEBhMCREUxJDAiBgNVBAoMG0RldXRzY2hlIFJlbnRl"
+ + "bnZlcnNpY2hlcnVuZzETMBEGA1UECwwKUUMgUm9vdCBDQQIDAjhuMA0GCSqGSIb3DQEBCwUABIIB"
+ + "AIOYgpDI0BaeG4RF/EB5QzkUqAZ9nX6w895+m2hHyRKrAKdj3913j5QI+aEVIG3DVbFaAfdKeKfn"
+ + "xsTW48aWs6aARtPAc+1OXwoGUSYElOFqqVpSeTaXe+kjY5bsLSQeETB+EPvXl8EcKTaxTRCNOqJU"
+ + "XbnyYRgWTI55A2jH6IsQQVHc5DaIcmbdI8iATaRTHY5eUeVuI+Q/3RMVBFAb5qRhM61Ddcrjq058"
+ + "C0uiH9G2IB5QRyu6RsCUgrkeMTMBqlIBlnDBy+EgLouDU4Dehxy5uzEl5DBKZEewZpQZOTO/kAgL"
+ + "WruAAg/Lj4r0f9vN12wRlHoS2UKDjrE1DnUBbrM=");
+
+ public string Name
+ {
+ get { return "ParseTest"; }
+ }
+
+ private static void requestParse(
+ byte[] request,
+ string algorithm)
+ {
+ TimeStampRequest req = new TimeStampRequest(request);
+
+ if (!req.MessageImprintAlgOid.Equals(algorithm))
+ {
+ Assert.Fail("failed to get expected algorithm - got "
+ + req.MessageImprintAlgOid + " not " + algorithm);
+ }
+
+ if (request != sha1Request && request != sha1noNonse)
+ {
+ if (!req.ReqPolicy.Equals(TspTestUtil.EuroPkiTsaTestPolicy.Id))
+ {
+ Assert.Fail("" + algorithm + " failed policy check.");
+ }
+
+ if (request == ripemd160Request)
+ {
+ if (!req.CertReq)
+ {
+ Assert.Fail("" + algorithm + " failed certReq check.");
+ }
+ }
+ }
+
+ Assert.AreEqual(1, req.Version, "version not 1");
+
+ Assert.IsNull(req.GetCriticalExtensionOids(), "critical extensions found when none expected");
+
+ Assert.IsNull(req.GetNonCriticalExtensionOids(), "non-critical extensions found when none expected");
+
+ if (request != sha1noNonse)
+ {
+ if (req.Nonce == null)
+ {
+ Assert.Fail("" + algorithm + " nonse not found when one expected.");
+ }
+ }
+ else
+ {
+ if (req.Nonce != null)
+ {
+ Assert.Fail("" + algorithm + " nonse not found when one not expected.");
+ }
+ }
+
+ try
+ {
+ req.Validate(TspAlgorithms.Allowed, null, null);
+ }
+ catch (Exception)
+ {
+ Assert.Fail("validation exception.");
+ }
+
+ if (!Arrays.AreEqual(req.GetEncoded(), request))
+ {
+ Assert.Fail("" + algorithm + " failed encode check.");
+ }
+ }
+
+ private static void responseParse(
+ byte[] request,
+ byte[] response,
+ string algorithm)
+ {
+ TimeStampRequest req = new TimeStampRequest(request);
+ TimeStampResponse resp = new TimeStampResponse(response);
+
+ resp.Validate(req);
+
+ X509Certificate cert = new X509CertificateParser().ReadCertificate(signingCert);
+
+ resp.TimeStampToken.Validate(cert);
+ }
+
+ private static void unacceptableResponseParse(
+ byte[] response)
+ {
+ TimeStampResponse resp = new TimeStampResponse(response);
+
+ if (resp.Status != (int) PkiStatus.Rejection)
+ {
+ Assert.Fail("request not rejected.");
+ }
+
+ if (resp.GetFailInfo().IntValue != PkiFailureInfo.UnacceptedPolicy)
+ {
+ Assert.Fail("request not rejected.");
+ }
+ }
+
+ private static void generalizedTimeParse(
+ byte[] response)
+ {
+ TimeStampResponse resp = new TimeStampResponse(response);
+
+ if (resp.Status != (int) PkiStatus.Granted)
+ {
+ Assert.Fail("request not rejected.");
+ }
+ }
+
+ [Test]
+ public void TestSha1()
+ {
+ requestParse(sha1Request, TspAlgorithms.Sha1);
+ requestParse(sha1noNonse, TspAlgorithms.Sha1);
+ responseParse(sha1Request, sha1Response, TspAlgorithms.Sha1);
+ responseParse(sha1noNonse, sha1noNonseResponse, TspAlgorithms.Sha1);
+ }
+
+ [Test]
+ public void TestMD5()
+ {
+ requestParse(md5Request, TspAlgorithms.MD5);
+ responseParse(md5Request, md5Response, TspAlgorithms.MD5);
+ }
+
+ [Test]
+ public void TestRipeMD160()
+ {
+ requestParse(ripemd160Request, TspAlgorithms.RipeMD160);
+ }
+
+ [Test]
+ public void TestUnacceptable()
+ {
+ unacceptableResponseParse(unacceptablePolicy);
+ }
+
+ [Test]
+ public void TestGeneralizedTime()
+ {
+ generalizedTimeParse(generalizedTime);
+ }
+
+ [Test]
+ public void TestV2SigningResponseParse()
+ {
+ v2SigningResponseParse(v2SigningCertResponse);
+ }
+
+ private void v2SigningResponseParse(
+ byte[] encoded)
+ {
+ TimeStampResponse response = new TimeStampResponse(encoded);
+
+ IX509Store store = response.TimeStampToken.GetCertificates("Collection");
+ X509Certificate cert = (X509Certificate)
+ new ArrayList(store.GetMatches(response.TimeStampToken.SignerID))[0];
+
+ response.TimeStampToken.Validate(cert);
+ }
+
+// public static void parse(
+// byte[] encoded,
+// bool tokenPresent)
+// {
+// TimeStampResponse response = new TimeStampResponse(encoded);
+//
+// if (tokenPresent && response.TimeStampToken == null)
+// {
+// Assert.Fail("token not found when expected.");
+// }
+// }
+ }
+}
diff --git a/crypto/test/src/tsp/test/TSPTest.cs b/crypto/test/src/tsp/test/TSPTest.cs
new file mode 100644
index 000000000..e56d4ec9f
--- /dev/null
+++ b/crypto/test/src/tsp/test/TSPTest.cs
@@ -0,0 +1,548 @@
+using System;
+using System.Collections;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Cmp;
+using Org.BouncyCastle.Asn1.Cms;
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.X509;
+using Org.BouncyCastle.X509.Store;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ [TestFixture]
+ public class TspTest
+ {
+ private static AsymmetricKeyParameter privateKey;
+ private static X509Certificate cert;
+ private static IX509Store certs;
+
+ static TspTest()
+ {
+ string signDN = "O=Bouncy Castle, C=AU";
+ AsymmetricCipherKeyPair signKP = TspTestUtil.MakeKeyPair();
+ X509Certificate signCert = TspTestUtil.MakeCACertificate(signKP, signDN, signKP, signDN);
+
+ string origDN = "CN=Eric H. Echidna, E=eric@bouncycastle.org, O=Bouncy Castle, C=AU";
+ AsymmetricCipherKeyPair origKP = TspTestUtil.MakeKeyPair();
+ privateKey = origKP.Private;
+
+ cert = TspTestUtil.MakeCertificate(origKP, origDN, signKP, signDN);
+
+ IList certList = new ArrayList();
+ certList.Add(cert);
+ certList.Add(signCert);
+
+ certs = X509StoreFactory.Create(
+ "Certificate/Collection",
+ new X509CollectionStoreParameters(certList));
+ }
+
+ [Test]
+ public void TestBasic()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ tsToken.Validate(cert);
+
+ AttributeTable table = tsToken.SignedAttributes;
+
+ Assert.IsNotNull(table[PkcsObjectIdentifiers.IdAASigningCertificate], "no signingCertificate attribute found");
+ }
+
+ [Test]
+ public void TestResponseValidation()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.MD5, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ tsToken.Validate(cert);
+
+ //
+ // check validation
+ //
+ tsResp.Validate(request);
+
+ try
+ {
+ request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(101));
+
+ tsResp.Validate(request);
+
+ Assert.Fail("response validation failed on invalid nonce.");
+ }
+ catch (TspValidationException)
+ {
+ // ignore
+ }
+
+ try
+ {
+ request = reqGen.Generate(TspAlgorithms.Sha1, new byte[22], BigInteger.ValueOf(100));
+
+ tsResp.Validate(request);
+
+ Assert.Fail("response validation failed on wrong digest.");
+ }
+ catch (TspValidationException)
+ {
+ // ignore
+ }
+
+ try
+ {
+ request = reqGen.Generate(TspAlgorithms.MD5, new byte[20], BigInteger.ValueOf(100));
+
+ tsResp.Validate(request);
+
+ Assert.Fail("response validation failed on wrong digest.");
+ }
+ catch (TspValidationException)
+ {
+ // ignore
+ }
+ }
+
+ [Test]
+ public void TestIncorrectHash()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[16]);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ if (tsToken != null)
+ {
+ Assert.Fail("incorrectHash - token not null.");
+ }
+
+ PkiFailureInfo failInfo = tsResp.GetFailInfo();
+
+ if (failInfo == null)
+ {
+ Assert.Fail("incorrectHash - failInfo set to null.");
+ }
+
+ if (failInfo.IntValue != PkiFailureInfo.BadDataFormat)
+ {
+ Assert.Fail("incorrectHash - wrong failure info returned.");
+ }
+ }
+
+ [Test]
+ public void TestBadAlgorithm()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate("1.2.3.4.5", new byte[20]);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ if (tsToken != null)
+ {
+ Assert.Fail("badAlgorithm - token not null.");
+ }
+
+ PkiFailureInfo failInfo = tsResp.GetFailInfo();
+
+ if (failInfo == null)
+ {
+ Assert.Fail("badAlgorithm - failInfo set to null.");
+ }
+
+ if (failInfo.IntValue != PkiFailureInfo.BadAlg)
+ {
+ Assert.Fail("badAlgorithm - wrong failure info returned.");
+ }
+ }
+
+ [Test]
+ public void TestTimeNotAvailable()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate("1.2.3.4.5", new byte[20]);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(
+ tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, new BigInteger("23"), null);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ if (tsToken != null)
+ {
+ Assert.Fail("timeNotAvailable - token not null.");
+ }
+
+ PkiFailureInfo failInfo = tsResp.GetFailInfo();
+
+ if (failInfo == null)
+ {
+ Assert.Fail("timeNotAvailable - failInfo set to null.");
+ }
+
+ if (failInfo.IntValue != PkiFailureInfo.TimeNotAvailable)
+ {
+ Assert.Fail("timeNotAvailable - wrong failure info returned.");
+ }
+ }
+
+ [Test]
+ public void TestBadPolicy()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+
+ reqGen.SetReqPolicy("1.1");
+
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20]);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed, new ArrayList());
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ if (tsToken != null)
+ {
+ Assert.Fail("badPolicy - token not null.");
+ }
+
+ PkiFailureInfo failInfo = tsResp.GetFailInfo();
+
+ if (failInfo == null)
+ {
+ Assert.Fail("badPolicy - failInfo set to null.");
+ }
+
+ if (failInfo.IntValue != PkiFailureInfo.UnacceptedPolicy)
+ {
+ Assert.Fail("badPolicy - wrong failure info returned.");
+ }
+ }
+
+ [Test]
+ public void TestCertReq()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.MD5, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+
+ //
+ // request with certReq false
+ //
+ reqGen.SetCertReq(false);
+
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ Assert.IsNull(tsToken.TimeStampInfo.GenTimeAccuracy); // check for abscence of accuracy
+
+ Assert.AreEqual("1.2", tsToken.TimeStampInfo.Policy);
+
+ try
+ {
+ tsToken.Validate(cert);
+ }
+ catch (TspValidationException)
+ {
+ Assert.Fail("certReq(false) verification of token failed.");
+ }
+
+ IX509Store respCerts = tsToken.GetCertificates("Collection");
+
+ ICollection certsColl = respCerts.GetMatches(null);
+
+ if (certsColl.Count != 0)
+ {
+ Assert.Fail("certReq(false) found certificates in response.");
+ }
+ }
+
+ [Test]
+ public void TestTokenEncoding()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.Sha1, "1.2.3.4.5.6");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampResponse tsResponse = new TimeStampResponse(tsResp.GetEncoded());
+
+ if (!Arrays.AreEqual(tsResponse.GetEncoded(), tsResp.GetEncoded())
+ || !Arrays.AreEqual(tsResponse.TimeStampToken.GetEncoded(),
+ tsResp.TimeStampToken.GetEncoded()))
+ {
+ Assert.Fail();
+ }
+ }
+
+ [Test]
+ public void TestAccuracyZeroCerts()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.MD5, "1.2");
+
+ tsTokenGen.SetCertificates(certs);
+
+ tsTokenGen.SetAccuracySeconds(1);
+ tsTokenGen.SetAccuracyMillis(2);
+ tsTokenGen.SetAccuracyMicros(3);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ tsToken.Validate(cert);
+
+ //
+ // check validation
+ //
+ tsResp.Validate(request);
+
+ //
+ // check tstInfo
+ //
+ TimeStampTokenInfo tstInfo = tsToken.TimeStampInfo;
+
+ //
+ // check accuracy
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.AreEqual(1, accuracy.Seconds);
+ Assert.AreEqual(2, accuracy.Millis);
+ Assert.AreEqual(3, accuracy.Micros);
+
+ Assert.AreEqual(BigInteger.ValueOf(23), tstInfo.SerialNumber);
+
+ Assert.AreEqual("1.2", tstInfo.Policy);
+
+ //
+ // test certReq
+ //
+ IX509Store store = tsToken.GetCertificates("Collection");
+
+ ICollection certificates = store.GetMatches(null);
+
+ Assert.AreEqual(0, certificates.Count);
+ }
+
+ [Test]
+ public void TestAccuracyWithCertsAndOrdering()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.MD5, "1.2.3");
+
+ tsTokenGen.SetCertificates(certs);
+
+ tsTokenGen.SetAccuracySeconds(3);
+ tsTokenGen.SetAccuracyMillis(1);
+ tsTokenGen.SetAccuracyMicros(2);
+
+ tsTokenGen.SetOrdering(true);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+
+ reqGen.SetCertReq(true);
+
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20], BigInteger.ValueOf(100));
+
+ Assert.IsTrue(request.CertReq);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(23), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ tsToken.Validate(cert);
+
+ //
+ // check validation
+ //
+ tsResp.Validate(request);
+
+ //
+ // check tstInfo
+ //
+ TimeStampTokenInfo tstInfo = tsToken.TimeStampInfo;
+
+ //
+ // check accuracy
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.AreEqual(3, accuracy.Seconds);
+ Assert.AreEqual(1, accuracy.Millis);
+ Assert.AreEqual(2, accuracy.Micros);
+
+ Assert.AreEqual(BigInteger.ValueOf(23), tstInfo.SerialNumber);
+
+ Assert.AreEqual("1.2.3", tstInfo.Policy);
+
+ Assert.AreEqual(true, tstInfo.IsOrdered);
+
+ Assert.AreEqual(tstInfo.Nonce, BigInteger.ValueOf(100));
+
+ //
+ // test certReq
+ //
+ IX509Store store = tsToken.GetCertificates("Collection");
+
+ ICollection certificates = store.GetMatches(null);
+
+ Assert.AreEqual(2, certificates.Count);
+ }
+
+ [Test]
+ public void TestNoNonce()
+ {
+ TimeStampTokenGenerator tsTokenGen = new TimeStampTokenGenerator(
+ privateKey, cert, TspAlgorithms.MD5, "1.2.3");
+
+ tsTokenGen.SetCertificates(certs);
+
+ TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
+ TimeStampRequest request = reqGen.Generate(TspAlgorithms.Sha1, new byte[20]);
+
+ Assert.IsFalse(request.CertReq);
+
+ TimeStampResponseGenerator tsRespGen = new TimeStampResponseGenerator(tsTokenGen, TspAlgorithms.Allowed);
+
+ TimeStampResponse tsResp = tsRespGen.Generate(request, BigInteger.ValueOf(24), DateTime.UtcNow);
+
+ tsResp = new TimeStampResponse(tsResp.GetEncoded());
+
+ TimeStampToken tsToken = tsResp.TimeStampToken;
+
+ tsToken.Validate(cert);
+
+ //
+ // check validation
+ //
+ tsResp.Validate(request);
+
+ //
+ // check tstInfo
+ //
+ TimeStampTokenInfo tstInfo = tsToken.TimeStampInfo;
+
+ //
+ // check accuracy
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.IsNull(accuracy);
+
+ Assert.AreEqual(BigInteger.ValueOf(24), tstInfo.SerialNumber);
+
+ Assert.AreEqual("1.2.3", tstInfo.Policy);
+
+ Assert.IsFalse(tstInfo.IsOrdered);
+
+ Assert.IsNull(tstInfo.Nonce);
+
+ //
+ // test certReq
+ //
+ IX509Store store = tsToken.GetCertificates("Collection");
+
+ ICollection certificates = store.GetMatches(null);
+
+ Assert.AreEqual(0, certificates.Count);
+ }
+ }
+}
diff --git a/crypto/test/src/tsp/test/TSPTestUtil.cs b/crypto/test/src/tsp/test/TSPTestUtil.cs
new file mode 100644
index 000000000..f7b0c833a
--- /dev/null
+++ b/crypto/test/src/tsp/test/TSPTestUtil.cs
@@ -0,0 +1,200 @@
+using System;
+using System.Text;
+
+using Org.BouncyCastle.Asn1;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Utilities.Encoders;
+using Org.BouncyCastle.X509;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ public class TspTestUtil
+ {
+ public static SecureRandom rand = new SecureRandom();
+ public static IAsymmetricCipherKeyPairGenerator kpg;
+ public static CipherKeyGenerator desede128kg;
+ public static CipherKeyGenerator desede192kg;
+ public static CipherKeyGenerator rc240kg;
+ public static CipherKeyGenerator rc264kg;
+ public static CipherKeyGenerator rc2128kg;
+ public static BigInteger serialNumber = BigInteger.One;
+ public static readonly bool Debug = true;
+ public static DerObjectIdentifier EuroPkiTsaTestPolicy = new DerObjectIdentifier("1.3.6.1.4.1.5255.5.1");
+
+ static TspTestUtil()
+ {
+ rand = new SecureRandom();
+
+ kpg = GeneratorUtilities.GetKeyPairGenerator("RSA");
+ kpg.Init(new RsaKeyGenerationParameters(
+ BigInteger.ValueOf(0x10001), rand, 1024, 25));
+
+ desede128kg = GeneratorUtilities.GetKeyGenerator("DESEDE");
+ desede128kg.Init(new KeyGenerationParameters(rand, 112));
+
+ desede192kg = GeneratorUtilities.GetKeyGenerator("DESEDE");
+ desede192kg.Init(new KeyGenerationParameters(rand, 168));
+
+ rc240kg = GeneratorUtilities.GetKeyGenerator("RC2");
+ rc240kg.Init(new KeyGenerationParameters(rand, 40));
+
+ rc264kg = GeneratorUtilities.GetKeyGenerator("RC2");
+ rc264kg.Init(new KeyGenerationParameters(rand, 64));
+
+ rc2128kg = GeneratorUtilities.GetKeyGenerator("RC2");
+ rc2128kg.Init(new KeyGenerationParameters(rand, 128));
+
+ serialNumber = BigInteger.One;
+ }
+
+ public static string DumpBase64(
+ byte[] data)
+ {
+ StringBuilder buf = new StringBuilder();
+
+ data = Base64.Encode(data);
+
+ for (int i = 0; i < data.Length; i += 64)
+ {
+ if (i + 64 < data.Length)
+ {
+ buf.Append(Encoding.ASCII.GetString(data, i, 64));
+ }
+ else
+ {
+ buf.Append(Encoding.ASCII.GetString(data, i, data.Length - i));
+ }
+ buf.Append('\n');
+ }
+
+ return buf.ToString();
+ }
+
+ public static AsymmetricCipherKeyPair MakeKeyPair()
+ {
+ return kpg.GenerateKeyPair();
+ }
+
+ public static KeyParameter MakeDesede128Key()
+ {
+ return new DesEdeParameters(desede128kg.GenerateKey());
+ }
+
+ public static KeyParameter MakeDesede192Key()
+ {
+ return new DesEdeParameters(desede192kg.GenerateKey());
+ }
+
+ public static KeyParameter MakeRC240Key()
+ {
+ return new RC2Parameters(rc240kg.GenerateKey());
+ }
+
+ public static KeyParameter MakeRC264Key()
+ {
+ return new RC2Parameters(rc264kg.GenerateKey());
+ }
+
+ public static KeyParameter MakeRC2128Key()
+ {
+ return new RC2Parameters(rc2128kg.GenerateKey());
+ }
+
+ public static X509Certificate MakeCertificate(AsymmetricCipherKeyPair _subKP,
+ string _subDN, AsymmetricCipherKeyPair _issKP, string _issDN)
+ {
+ return MakeCertificate(_subKP, _subDN, _issKP, _issDN, false);
+ }
+
+ public static X509Certificate MakeCACertificate(AsymmetricCipherKeyPair _subKP,
+ string _subDN, AsymmetricCipherKeyPair _issKP, string _issDN)
+ {
+ return MakeCertificate(_subKP, _subDN, _issKP, _issDN, true);
+ }
+
+ public static X509Certificate MakeCertificate(AsymmetricCipherKeyPair _subKP,
+ string _subDN, AsymmetricCipherKeyPair _issKP, string _issDN, bool _ca)
+ {
+ AsymmetricKeyParameter _subPub = _subKP.Public;
+ AsymmetricKeyParameter _issPriv = _issKP.Private;
+ AsymmetricKeyParameter _issPub = _issKP.Public;
+
+ X509V3CertificateGenerator _v3CertGen = new X509V3CertificateGenerator();
+
+ _v3CertGen.Reset();
+ _v3CertGen.SetSerialNumber(allocateSerialNumber());
+ _v3CertGen.SetIssuerDN(new X509Name(_issDN));
+ _v3CertGen.SetNotBefore(DateTime.UtcNow);
+ _v3CertGen.SetNotAfter(DateTime.UtcNow.AddDays(100));
+ _v3CertGen.SetSubjectDN(new X509Name(_subDN));
+ _v3CertGen.SetPublicKey(_subPub);
+ _v3CertGen.SetSignatureAlgorithm("MD5WithRSAEncryption");
+
+ _v3CertGen.AddExtension(X509Extensions.SubjectKeyIdentifier, false,
+ createSubjectKeyId(_subPub));
+
+ _v3CertGen.AddExtension(X509Extensions.AuthorityKeyIdentifier, false,
+ createAuthorityKeyId(_issPub));
+
+ if (_ca)
+ {
+ _v3CertGen.AddExtension(X509Extensions.BasicConstraints, false,
+ new BasicConstraints(_ca));
+ }
+ else
+ {
+ _v3CertGen.AddExtension(X509Extensions.ExtendedKeyUsage, true,
+ ExtendedKeyUsage.GetInstance(new DerSequence(KeyPurposeID.IdKPTimeStamping)));
+ }
+
+ X509Certificate _cert = _v3CertGen.Generate(_issPriv);
+
+ _cert.CheckValidity(DateTime.UtcNow);
+ _cert.Verify(_issPub);
+
+ return _cert;
+ }
+
+ /*
+ *
+ * INTERNAL METHODS
+ *
+ */
+ private static AuthorityKeyIdentifier createAuthorityKeyId(
+ AsymmetricKeyParameter _pubKey)
+ {
+ return new AuthorityKeyIdentifier(
+ SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_pubKey));
+ }
+
+// private static AuthorityKeyIdentifier createAuthorityKeyId(
+// AsymmetricKeyParameter _pubKey, X509Name _name, int _sNumber)
+// {
+// SubjectPublicKeyInfo _info = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_pubKey);
+//
+// GeneralName _genName = new GeneralName(_name);
+//
+// return new AuthorityKeyIdentifier(_info, GeneralNames.GetInstance(
+// new DerSequence(_genName)), BigInteger.ValueOf(_sNumber));
+// }
+
+ private static SubjectKeyIdentifier createSubjectKeyId(
+ AsymmetricKeyParameter _pubKey)
+ {
+ return new SubjectKeyIdentifier(
+ SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(_pubKey));
+ }
+
+ private static BigInteger allocateSerialNumber()
+ {
+ BigInteger _tmp = serialNumber;
+ serialNumber = serialNumber.Add(BigInteger.One);
+ return _tmp;
+ }
+ }
+}
\ No newline at end of file
diff --git a/crypto/test/src/tsp/test/TimeStampTokenInfoTest.cs b/crypto/test/src/tsp/test/TimeStampTokenInfoTest.cs
new file mode 100644
index 000000000..5a26f5ef6
--- /dev/null
+++ b/crypto/test/src/tsp/test/TimeStampTokenInfoTest.cs
@@ -0,0 +1,145 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1;
+using Org.BouncyCastle.Asn1.Tsp;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Date;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Tsp.Tests
+{
+ [TestFixture]
+ public class TimeStampTokenInfoUnitTest
+ {
+ private static readonly byte[] tstInfo1 = Hex.Decode(
+ "303e02010106022a033021300906052b0e03021a050004140000000000000000000000000000000000000000"
+ + "020118180f32303035313130313038313732315a");
+
+ private static readonly byte[] tstInfo2 = Hex.Decode(
+ "304c02010106022a033021300906052b0e03021a05000414ffffffffffffffffffffffffffffffffffffffff"
+ + "020117180f32303035313130313038323934355a3009020103800101810102020164");
+
+ private static readonly byte[] tstInfo3 = Hex.Decode(
+ "304f02010106022a033021300906052b0e03021a050004140000000000000000000000000000000000000000"
+ + "020117180f32303035313130313038343733355a30090201038001018101020101ff020164");
+
+ private static readonly byte[] tstInfoDudDate = Hex.Decode(
+ "303e02010106022a033021300906052b0e03021a050004140000000000000000000000000000000000000000"
+ + "020118180f32303056313130313038313732315a");
+
+ [Test]
+ public void TestTstInfo1()
+ {
+ TimeStampTokenInfo tstInfo = getTimeStampTokenInfo(tstInfo1);
+
+ //
+ // verify
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.IsNull(accuracy);
+
+ Assert.AreEqual(new BigInteger("24"), tstInfo.SerialNumber);
+
+ Assert.AreEqual(1130833041000L, DateTimeUtilities.DateTimeToUnixMs(tstInfo.GenTime));
+
+ Assert.AreEqual("1.2.3", tstInfo.Policy);
+
+ Assert.AreEqual(false, tstInfo.IsOrdered);
+
+ Assert.IsNull(tstInfo.Nonce);
+
+ Assert.AreEqual(TspAlgorithms.Sha1, tstInfo.MessageImprintAlgOid);
+
+ Assert.IsTrue(Arrays.AreEqual(new byte[20], tstInfo.GetMessageImprintDigest()));
+
+ Assert.IsTrue(Arrays.AreEqual(tstInfo1, tstInfo.GetEncoded()));
+ }
+
+ [Test]
+ public void TestTstInfo2()
+ {
+ TimeStampTokenInfo tstInfo = getTimeStampTokenInfo(tstInfo2);
+
+ //
+ // verify
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.AreEqual(3, accuracy.Seconds);
+ Assert.AreEqual(1, accuracy.Millis);
+ Assert.AreEqual(2, accuracy.Micros);
+
+ Assert.AreEqual(new BigInteger("23"), tstInfo.SerialNumber);
+
+ Assert.AreEqual(1130833785000L, DateTimeUtilities.DateTimeToUnixMs(tstInfo.GenTime));
+
+ Assert.AreEqual("1.2.3", tstInfo.Policy);
+
+ Assert.AreEqual(false, tstInfo.IsOrdered);
+
+ Assert.AreEqual(tstInfo.Nonce, BigInteger.ValueOf(100));
+
+ Assert.IsTrue(Arrays.AreEqual(Hex.Decode("ffffffffffffffffffffffffffffffffffffffff"), tstInfo.GetMessageImprintDigest()));
+
+ Assert.IsTrue(Arrays.AreEqual(tstInfo2, tstInfo.GetEncoded()));
+ }
+
+ [Test]
+ public void TestTstInfo3()
+ {
+ TimeStampTokenInfo tstInfo = getTimeStampTokenInfo(tstInfo3);
+
+ //
+ // verify
+ //
+ GenTimeAccuracy accuracy = tstInfo.GenTimeAccuracy;
+
+ Assert.AreEqual(3, accuracy.Seconds);
+ Assert.AreEqual(1, accuracy.Millis);
+ Assert.AreEqual(2, accuracy.Micros);
+
+ Assert.AreEqual(new BigInteger("23"), tstInfo.SerialNumber);
+
+ Assert.AreEqual(1130834855000L, DateTimeUtilities.DateTimeToUnixMs(tstInfo.GenTime));
+
+ Assert.AreEqual("1.2.3", tstInfo.Policy);
+
+ Assert.AreEqual(true, tstInfo.IsOrdered);
+
+ Assert.AreEqual(tstInfo.Nonce, BigInteger.ValueOf(100));
+
+ Assert.AreEqual(TspAlgorithms.Sha1, tstInfo.MessageImprintAlgOid);
+
+ Assert.IsTrue(Arrays.AreEqual(new byte[20], tstInfo.GetMessageImprintDigest()));
+
+ Assert.IsTrue(Arrays.AreEqual(tstInfo3, tstInfo.GetEncoded()));
+ }
+
+ [Test]
+ public void TestTstInfoDudDate()
+ {
+ try
+ {
+ getTimeStampTokenInfo(tstInfoDudDate);
+
+ Assert.Fail("dud date not detected.");
+ }
+ catch (TspException)
+ {
+ // expected
+ }
+ }
+
+ private TimeStampTokenInfo getTimeStampTokenInfo(
+ byte[] tstInfo)
+ {
+ return new TimeStampTokenInfo(
+ TstInfo.GetInstance(
+ Asn1Object.FromByteArray(tstInfo)));
+ }
+ }
+}
|
