Asn1.Tsp updates from bc-java

15 files changed, 1032 insertions, 343 deletions

diff --git a/crypto/src/asn1/DerBitString.cs b/crypto/src/asn1/DerBitString.cs
index caa97933f..f543a968d 100644
--- a/crypto/src/asn1/DerBitString.cs
+++ b/crypto/src/asn1/DerBitString.cs
@@ -31,11 +31,6 @@ namespace Org.BouncyCastle.Asn1
         private static readonly char[] table
 			= { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
-        /**
-		 * return a Bit string from the passed in object
-		 *
-		 * @exception ArgumentException if the object cannot be converted.
-		 */
 		public static DerBitString GetInstance(object obj)
 		{
             if (obj == null)
@@ -65,15 +60,6 @@ namespace Org.BouncyCastle.Asn1
             throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj));
 		}
 
-		/**
-		 * return a Bit string from a tagged object.
-		 *
-		 * @param obj the tagged object holding the object we want
-		 * @param explicitly true if the object is meant to be explicitly
-		 *              tagged false otherwise.
-		 * @exception ArgumentException if the tagged object cannot
-		 *               be converted.
-		 */
         public static DerBitString GetInstance(Asn1TaggedObject obj, bool isExplicit)
         {
             return (DerBitString)Meta.Instance.GetContextInstance(obj, isExplicit);
diff --git a/crypto/src/asn1/cms/Attributes.cs b/crypto/src/asn1/cms/Attributes.cs
index 5b6b13034..010684158 100644
--- a/crypto/src/asn1/cms/Attributes.cs
+++ b/crypto/src/asn1/cms/Attributes.cs
@@ -5,41 +5,34 @@ namespace Org.BouncyCastle.Asn1.Cms
     public class Attributes
         : Asn1Encodable
     {
-        private readonly Asn1Set attributes;
-
-        private Attributes(Asn1Set attributes)
+        public static Attributes GetInstance(object obj)
         {
-            this.attributes = attributes;
+            if (obj == null)
+                return null;
+            if (obj is Attributes attributes)
+                return attributes;
+            return new Attributes(Asn1Set.GetInstance(obj));
         }
 
-        public Attributes(Asn1EncodableVector v)
+        public static Attributes GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
         {
-            attributes = new BerSet(v);
+            return GetInstance(Asn1Set.GetInstance(taggedObject, declaredExplicit));
         }
 
-        public static Attributes GetInstance(object obj)
-        {
-            if (obj is Attributes)
-                return (Attributes)obj;
+        private readonly Asn1Set m_attributes;
 
-            if (obj != null)
-                return new Attributes(Asn1Set.GetInstance(obj));
-
-            return null;
+        private Attributes(Asn1Set attributes)
+        {
+            m_attributes = attributes;
         }
 
-        public virtual Attribute[] GetAttributes()
+        public Attributes(Asn1EncodableVector v)
         {
-            Attribute[] rv = new Attribute[attributes.Count];
-
-            for (int i = 0; i != rv.Length; i++)
-            {
-                rv[i] = Attribute.GetInstance(attributes[i]);
-            }
-
-            return rv;
+            m_attributes = new BerSet(v);
         }
 
+        public virtual Attribute[] GetAttributes() => m_attributes.MapElements(Attribute.GetInstance);
+
         /**
          * <pre>
          * Attributes ::=
@@ -47,9 +40,6 @@ namespace Org.BouncyCastle.Asn1.Cms
          * </pre>
          * @return
          */
-        public override Asn1Object ToAsn1Object()
-        {
-            return attributes;
-        }
+        public override Asn1Object ToAsn1Object() => m_attributes;
     }
 }
diff --git a/crypto/src/asn1/cms/OriginatorIdentifierOrKey.cs b/crypto/src/asn1/cms/OriginatorIdentifierOrKey.cs
index 6b4c0488e..12b1f518d 100644
--- a/crypto/src/asn1/cms/OriginatorIdentifierOrKey.cs
+++ b/crypto/src/asn1/cms/OriginatorIdentifierOrKey.cs
@@ -8,6 +8,35 @@ namespace Org.BouncyCastle.Asn1.Cms
     public class OriginatorIdentifierOrKey
         : Asn1Encodable, IAsn1Choice
     {
+        public static OriginatorIdentifierOrKey GetInstance(
+            object o)
+        {
+            if (o == null)
+                return null;
+
+            if (o is OriginatorIdentifierOrKey originatorIdentifierOrKey)
+                return originatorIdentifierOrKey;
+
+            if (o is IssuerAndSerialNumber issuerAndSerialNumber)
+                return new OriginatorIdentifierOrKey(issuerAndSerialNumber);
+
+            if (o is SubjectKeyIdentifier subjectKeyIdentifier)
+                return new OriginatorIdentifierOrKey(subjectKeyIdentifier);
+
+            if (o is OriginatorPublicKey originatorPublicKey)
+                return new OriginatorIdentifierOrKey(originatorPublicKey);
+
+            if (o is Asn1TaggedObject taggedObject)
+                return new OriginatorIdentifierOrKey(Asn1Utilities.CheckTagClass(taggedObject, Asn1Tags.ContextSpecific));
+
+            throw new ArgumentException("Invalid OriginatorIdentifierOrKey: " + Platform.GetTypeName(o));
+        }
+
+        public static OriginatorIdentifierOrKey GetInstance(Asn1TaggedObject o, bool explicitly)
+        {
+            return Asn1Utilities.GetInstanceFromChoice(o, explicitly, GetInstance);
+        }
+
         private readonly Asn1Encodable id;
 
         public OriginatorIdentifierOrKey(IssuerAndSerialNumber id)
@@ -31,50 +60,6 @@ namespace Org.BouncyCastle.Asn1.Cms
 			this.id = id;
 		}
 
-		/**
-         * return an OriginatorIdentifierOrKey object from a tagged object.
-         *
-         * @param o the tagged object holding the object we want.
-         * @param explicitly true if the object is meant to be explicitly
-         *              tagged false otherwise.
-         * @exception ArgumentException if the object held by the
-         *          tagged object cannot be converted.
-         */
-        public static OriginatorIdentifierOrKey GetInstance(Asn1TaggedObject o, bool explicitly)
-        {
-            return Asn1Utilities.GetInstanceFromChoice(o, explicitly, GetInstance);
-        }
-
-        /**
-         * return an OriginatorIdentifierOrKey object from the given object.
-         *
-         * @param o the object we want converted.
-         * @exception ArgumentException if the object cannot be converted.
-         */
-        public static OriginatorIdentifierOrKey GetInstance(
-            object o)
-        {
-            if (o == null)
-                return null;
-
-            if (o is OriginatorIdentifierOrKey originatorIdentifierOrKey)
-                return originatorIdentifierOrKey;
-
-			if (o is IssuerAndSerialNumber issuerAndSerialNumber)
-				return new OriginatorIdentifierOrKey(issuerAndSerialNumber);
-
-			if (o is SubjectKeyIdentifier subjectKeyIdentifier)
-				return new OriginatorIdentifierOrKey(subjectKeyIdentifier);
-
-			if (o is OriginatorPublicKey originatorPublicKey)
-				return new OriginatorIdentifierOrKey(originatorPublicKey);
-
-			if (o is Asn1TaggedObject taggedObject)
-				return new OriginatorIdentifierOrKey(Asn1Utilities.CheckTagClass(taggedObject, Asn1Tags.ContextSpecific));
-
-            throw new ArgumentException("Invalid OriginatorIdentifierOrKey: " + Platform.GetTypeName(o));
-        }
-
 		public Asn1Encodable ID
 		{
 			get { return id; }
diff --git a/crypto/src/asn1/tsp/Accuracy.cs b/crypto/src/asn1/tsp/Accuracy.cs
index f9cd88014..a4fd0443b 100644
--- a/crypto/src/asn1/tsp/Accuracy.cs
+++ b/crypto/src/asn1/tsp/Accuracy.cs
@@ -7,21 +7,31 @@ namespace Org.BouncyCastle.Asn1.Tsp
 	public class Accuracy
 		: Asn1Encodable
 	{
-		private readonly DerInteger seconds;
-		private readonly DerInteger millis;
-		private readonly DerInteger micros;
+        protected const int MinMillis = 1;
+        protected const int MaxMillis = 999;
+        protected const int MinMicros = 1;
+        protected const int MaxMicros = 999;
 
-		// constants
-		protected const int MinMillis = 1;
-		protected const int MaxMillis = 999;
-		protected const int MinMicros = 1;
-		protected const int MaxMicros = 999;
+        public static Accuracy GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is Accuracy accuracy)
+                return accuracy;
+            return new Accuracy(Asn1Sequence.GetInstance(obj));
+        }
 
-		public Accuracy(
-			DerInteger seconds,
-			DerInteger millis,
-			DerInteger micros)
-		{
+        public static Accuracy GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new Accuracy(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly DerInteger m_seconds;
+        private readonly DerInteger m_millis;
+        private readonly DerInteger m_micros;
+
+        public Accuracy(DerInteger seconds, DerInteger millis, DerInteger micros)
+        {
             if (null != millis)
             {
                 int millisValue = millis.IntValueExact;
@@ -35,22 +45,26 @@ namespace Org.BouncyCastle.Asn1.Tsp
                     throw new ArgumentException("Invalid micros field : not in (1..999)");
             }
 
-            this.seconds = seconds;
-            this.millis = millis;
-            this.micros = micros;
-		}
+            m_seconds = seconds;
+            m_millis = millis;
+            m_micros = micros;
+        }
+
+        private Accuracy(Asn1Sequence seq)
+        {
+            DerInteger seconds = null;
+            DerInteger millis = null;
+            DerInteger micros = null;
 
-		private Accuracy(Asn1Sequence seq)
-		{
-			for (int i = 0; i < seq.Count; ++i)
-			{
-				// seconds
-				if (seq[i] is DerInteger derInteger)
-				{
-					seconds = derInteger;
-				}
+            for (int i = 0; i < seq.Count; ++i)
+            {
+                // seconds
+                if (seq[i] is DerInteger derInteger)
+                {
+                    seconds = derInteger;
+                }
                 else if (seq[i] is Asn1TaggedObject extra)
-				{
+                {
                     switch (extra.TagNo)
                     {
                     case 0:
@@ -68,35 +82,21 @@ namespace Org.BouncyCastle.Asn1.Tsp
                     default:
                         throw new ArgumentException("Invalid tag number");
                     }
-				}
-			}
-		}
+                }
+            }
 
-        public static Accuracy GetInstance(object obj)
-        {
-            if (obj is Accuracy)
-                return (Accuracy)obj;
-            if (obj == null)
-                return null;
-            return new Accuracy(Asn1Sequence.GetInstance(obj));
+            m_seconds = seconds;
+            m_millis = millis;
+            m_micros = micros;
         }
 
-        public DerInteger Seconds
-		{
-			get { return seconds; }
-		}
+        public DerInteger Seconds => m_seconds;
 
-		public DerInteger Millis
-		{
-			get { return millis; }
-		}
+        public DerInteger Millis => m_millis;
 
-		public DerInteger Micros
-		{
-			get { return micros; }
-		}
+        public DerInteger Micros => m_micros;
 
-		/**
+        /**
 		 * <pre>
 		 * Accuracy ::= SEQUENCE {
 		 *             seconds        INTEGER              OPTIONAL,
@@ -108,10 +108,10 @@ namespace Org.BouncyCastle.Asn1.Tsp
         public override Asn1Object ToAsn1Object()
         {
             Asn1EncodableVector v = new Asn1EncodableVector(3);
-            v.AddOptional(seconds);
-            v.AddOptionalTagged(false, 0, millis);
-            v.AddOptionalTagged(false, 1, micros);
+            v.AddOptional(m_seconds);
+            v.AddOptionalTagged(false, 0, m_millis);
+            v.AddOptionalTagged(false, 1, m_micros);
             return new DerSequence(v);
         }
-	}
+    }
 }
diff --git a/crypto/src/asn1/tsp/ArchiveTimeStamp.cs b/crypto/src/asn1/tsp/ArchiveTimeStamp.cs
new file mode 100644
index 000000000..57cc02138
--- /dev/null
+++ b/crypto/src/asn1/tsp/ArchiveTimeStamp.cs
@@ -0,0 +1,176 @@
+using System;
+
+using Org.BouncyCastle.Asn1.Cms;
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of the Archive Timestamp type defined in RFC4998.
+     * @see <a href="https://tools.ietf.org/html/rfc4998">RFC 4998</a>
+     * <p>
+     * ASN.1 Archive Timestamp
+     * <p>
+     * ArchiveTimeStamp ::= SEQUENCE {
+     * digestAlgorithm [Ø] AlgorithmIdentifier OPTIONAL,
+     * attributes      [1] Attributes OPTIONAL,
+     * reducedHashtree [2] SEQUENCE OF PartialHashtree OPTIONAL,
+     * timeStamp       ContentInfo}
+     * <p>
+     * PartialHashtree ::= SEQUENCE OF OCTET STRING
+     * <p>
+     * Attributes ::= SET SIZE (1..MAX) OF Attribute
+     */
+    public class ArchiveTimeStamp
+        : Asn1Encodable
+    {
+        /**
+         * Return an ArchiveTimestamp from the given object.
+         *
+         * @param obj the object we want converted.
+         * @return an ArchiveTimestamp instance, or null.
+         * @throws IllegalArgumentException if the object cannot be converted.
+         */
+        public static ArchiveTimeStamp GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is ArchiveTimeStamp archiveTimeStamp)
+                return archiveTimeStamp;
+            return new ArchiveTimeStamp(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static ArchiveTimeStamp GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new ArchiveTimeStamp(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly AlgorithmIdentifier m_digestAlgorithm;
+        private readonly Attributes m_attributes;
+        private readonly Asn1Sequence m_reducedHashTree;
+        private readonly ContentInfo m_timeStamp;
+
+        public ArchiveTimeStamp(AlgorithmIdentifier digestAlgorithm, PartialHashtree[] reducedHashTree,
+            ContentInfo timeStamp)
+            : this(digestAlgorithm, null, reducedHashTree, timeStamp)
+        {
+        }
+
+        public ArchiveTimeStamp(ContentInfo timeStamp)
+            : this(null, null, null, timeStamp)
+        {
+        }
+
+        public ArchiveTimeStamp(AlgorithmIdentifier digestAlgorithm, Attributes attributes,
+            PartialHashtree[] reducedHashTree, ContentInfo timeStamp)
+        {
+            m_digestAlgorithm = digestAlgorithm;
+            m_attributes = attributes;
+            if (reducedHashTree != null)
+            {
+                m_reducedHashTree = new DerSequence(reducedHashTree);
+            }
+            else
+            {
+                m_reducedHashTree = null;
+            }
+            m_timeStamp = timeStamp;
+        }
+
+        private ArchiveTimeStamp(Asn1Sequence sequence)
+        {
+            if (sequence.Count < 1 || sequence.Count > 4)
+                throw new ArgumentException("wrong sequence size in constructor: " + sequence.Count, nameof(sequence));
+
+            AlgorithmIdentifier digAlg = null;
+            Attributes attrs = null;
+            Asn1Sequence rHashTree = null;
+            for (int i = 0; i < sequence.Count - 1; i++)
+            {
+                Asn1Encodable obj = sequence[i];
+
+                if (obj is Asn1TaggedObject taggedObject)
+                {
+                    switch (taggedObject.TagNo)
+                    {
+                    case 0:
+                        digAlg = AlgorithmIdentifier.GetInstance(taggedObject, false);
+                        break;
+                    case 1:
+                        attrs = Attributes.GetInstance(taggedObject, false);
+                        break;
+                    case 2:
+                        rHashTree = Asn1Sequence.GetInstance(taggedObject, false);
+                        break;
+                    default:
+                        throw new ArgumentException("invalid tag no in constructor: " + taggedObject.TagNo);
+                    }
+                }
+            }
+
+            m_digestAlgorithm = digAlg;
+            m_attributes = attrs;
+            m_reducedHashTree = rHashTree;
+            m_timeStamp = ContentInfo.GetInstance(sequence[sequence.Count - 1]);
+        }
+
+        public virtual AlgorithmIdentifier GetDigestAlgorithmIdentifier() => m_digestAlgorithm
+            ?? GetTimeStampInfo().MessageImprint.HashAlgorithm;
+
+        public virtual byte[] GetTimeStampDigestValue() => GetTimeStampInfo().MessageImprint.GetHashedMessage();
+
+        private TstInfo GetTimeStampInfo()
+        {
+            if (!CmsObjectIdentifiers.SignedData.Equals(m_timeStamp.ContentType))
+                throw new InvalidOperationException("cannot identify algorithm identifier for digest");
+
+            SignedData tsData = SignedData.GetInstance(m_timeStamp.Content);
+            var contentInfo = tsData.EncapContentInfo;
+
+            if (!Asn1.Pkcs.PkcsObjectIdentifiers.IdCTTstInfo.Equals(contentInfo.ContentType))
+                throw new InvalidOperationException("cannot parse time stamp");
+
+            return TstInfo.GetInstance(Asn1OctetString.GetInstance(contentInfo.Content).GetOctets());
+        }
+
+        /**
+         * Return the contents of the digestAlgorithm field - null if not set.
+         *
+         * @return the contents of the digestAlgorithm field, or null if not set.
+         */
+        public virtual AlgorithmIdentifier DigestAlgorithm() => m_digestAlgorithm;
+
+        /**
+         * Return the first node in the reduced hash tree which contains the leaf node.
+         *
+         * @return the node containing the data hashes, null if no reduced hash tree is present.
+         */
+        public virtual PartialHashtree GetHashTreeLeaf()
+        {
+            if (m_reducedHashTree == null)
+                return null;
+
+            return PartialHashtree.GetInstance(m_reducedHashTree[0]);
+        }
+
+        public virtual PartialHashtree[] GetReducedHashTree()
+        {
+            if (m_reducedHashTree == null)
+                return null;
+
+            return m_reducedHashTree.MapElements(PartialHashtree.GetInstance);
+        }
+
+        public virtual ContentInfo TimeStamp => m_timeStamp;
+
+        public override Asn1Object ToAsn1Object()
+        {
+            Asn1EncodableVector v = new Asn1EncodableVector(4);
+            v.AddOptionalTagged(false, 0, m_digestAlgorithm);
+            v.AddOptionalTagged(false, 1, m_attributes);
+            v.AddOptionalTagged(false, 2, m_reducedHashTree);
+            v.Add(m_timeStamp);
+            return new DerSequence(v);
+        }
+    }
+}
diff --git a/crypto/src/asn1/tsp/ArchiveTimeStampChain.cs b/crypto/src/asn1/tsp/ArchiveTimeStampChain.cs
new file mode 100644
index 000000000..13138d6f9
--- /dev/null
+++ b/crypto/src/asn1/tsp/ArchiveTimeStampChain.cs
@@ -0,0 +1,86 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of ArchiveTimeStampChain type, as defined in RFC4998 and RFC6283.
+     * <p>
+     * An ArchiveTimeStampChain corresponds to a SEQUENCE OF ArchiveTimeStamps, and has the following
+     * ASN.1 Syntax:
+     * <p>
+     * ArchiveTimeStampChain ::= SEQUENCE OF ArchiveTimeStamp
+     */
+    public class ArchiveTimeStampChain
+        : Asn1Encodable
+    {
+        /**
+         * Return an ArchiveTimeStampChain from the given object.
+         *
+         * @param obj the object we want converted.
+         * @return an ArchiveTimeStampChain instance, or null.
+         * @throws IllegalArgumentException if the object cannot be converted.
+         */
+        public static ArchiveTimeStampChain GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is ArchiveTimeStampChain archiveTimeStampChain)
+                return archiveTimeStampChain;
+            return new ArchiveTimeStampChain(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static ArchiveTimeStampChain GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new ArchiveTimeStampChain(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly Asn1Sequence m_archiveTimeStamps;
+
+        public ArchiveTimeStampChain(ArchiveTimeStamp archiveTimeStamp)
+        {
+            m_archiveTimeStamps = new DerSequence(archiveTimeStamp);
+        }
+
+        public ArchiveTimeStampChain(ArchiveTimeStamp[] archiveTimeStamps)
+        {
+            m_archiveTimeStamps = new DerSequence(archiveTimeStamps);
+        }
+
+        private ArchiveTimeStampChain(Asn1Sequence sequence)
+        {
+            Asn1EncodableVector vector = new Asn1EncodableVector(sequence.Count);
+
+            foreach (var element in sequence)
+            {
+                vector.Add(ArchiveTimeStamp.GetInstance(element));
+            }
+
+            m_archiveTimeStamps = new DerSequence(vector);
+        }
+
+        public virtual ArchiveTimeStamp[] GetArchiveTimestamps() =>
+            m_archiveTimeStamps.MapElements(ArchiveTimeStamp.GetInstance);
+
+        /**
+         * Adds an {@link ArchiveTimeStamp} object to the archive timestamp chain.
+         *
+         * @param archiveTimeStamp the {@link ArchiveTimeStamp} to add.
+         * @return returns the modified chain.
+         */
+        public virtual ArchiveTimeStampChain Append(ArchiveTimeStamp archiveTimeStamp)
+        {
+            Asn1EncodableVector v = new Asn1EncodableVector(m_archiveTimeStamps.Count + 1);
+
+            foreach (var element in m_archiveTimeStamps)
+            {
+                v.Add(element);
+            }
+
+            v.Add(archiveTimeStamp);
+
+            return new ArchiveTimeStampChain(new DerSequence(v));
+        }
+
+        public override Asn1Object ToAsn1Object() => m_archiveTimeStamps;
+    }
+}
diff --git a/crypto/src/asn1/tsp/ArchiveTimeStampSequence.cs b/crypto/src/asn1/tsp/ArchiveTimeStampSequence.cs
new file mode 100644
index 000000000..766f6704c
--- /dev/null
+++ b/crypto/src/asn1/tsp/ArchiveTimeStampSequence.cs
@@ -0,0 +1,93 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of ArchiveTimeStampSequence type, as defined in RFC4998.
+     * <p>
+     * An ArchiveTimeStampSequence corresponds to a SEQUENCE OF ArchiveTimeStampChains and has the
+     * following ASN.1 Syntax:
+     * <p>
+     * ArchiveTimeStampSequence ::= SEQUENCE OF ArchiveTimeStampChain
+     */
+    public class ArchiveTimeStampSequence
+        : Asn1Encodable
+    {
+        /**
+         * Return an ArchiveTimestampSequence from the given object.
+         *
+         * @param obj the object we want converted.
+         * @return an ArchiveTimeStampSequence instance, or null.
+         * @throws IllegalArgumentException if the object cannot be converted.
+         */
+        public static ArchiveTimeStampSequence GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is ArchiveTimeStampSequence archiveTimeStampSequence)
+                return archiveTimeStampSequence;
+            return new ArchiveTimeStampSequence(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static ArchiveTimeStampSequence GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new ArchiveTimeStampSequence(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly Asn1Sequence m_archiveTimeStampChains;
+
+        private ArchiveTimeStampSequence(Asn1Sequence sequence)
+        {
+            Asn1EncodableVector vector = new Asn1EncodableVector(sequence.Count);
+
+            foreach (var element in sequence)
+            {
+                vector.Add(ArchiveTimeStampChain.GetInstance(element));
+            }
+
+            m_archiveTimeStampChains = new DerSequence(vector);
+        }
+
+        public ArchiveTimeStampSequence(ArchiveTimeStampChain archiveTimeStampChain)
+        {
+            m_archiveTimeStampChains = new DerSequence(archiveTimeStampChain);
+        }
+
+        public ArchiveTimeStampSequence(ArchiveTimeStampChain[] archiveTimeStampChains)
+        {
+            m_archiveTimeStampChains = new DerSequence(archiveTimeStampChains);
+        }
+
+        /**
+         * Returns the sequence of ArchiveTimeStamp chains that compose the ArchiveTimeStamp sequence.
+         *
+         * @return the {@link ASN1Sequence} containing the ArchiveTimeStamp chains.
+         */
+        public virtual ArchiveTimeStampChain[] GetArchiveTimeStampChains() =>
+            m_archiveTimeStampChains.MapElements(ArchiveTimeStampChain.GetInstance);
+
+        public virtual int Count => m_archiveTimeStampChains.Count;
+
+        /**
+         * Adds an {@link ArchiveTimeStampChain} to the ArchiveTimeStamp sequence.
+         *
+         * @param chain the {@link ArchiveTimeStampChain} to add
+         * @return returns the modified sequence.
+         */
+        public virtual ArchiveTimeStampSequence Append(ArchiveTimeStampChain chain)
+        {
+            Asn1EncodableVector v = new Asn1EncodableVector(m_archiveTimeStampChains.Count + 1);
+
+            foreach (var element in m_archiveTimeStampChains)
+            {
+                v.Add(element);
+            }
+
+            v.Add(chain);
+
+            return new ArchiveTimeStampSequence(new DerSequence(v));
+        }
+
+        public override Asn1Object ToAsn1Object() => m_archiveTimeStampChains;
+    }
+}
diff --git a/crypto/src/asn1/tsp/CryptoInfos.cs b/crypto/src/asn1/tsp/CryptoInfos.cs
new file mode 100644
index 000000000..b0b84c014
--- /dev/null
+++ b/crypto/src/asn1/tsp/CryptoInfos.cs
@@ -0,0 +1,43 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of the CryptoInfos element defined in RFC 4998:
+     * <p>
+     * CryptoInfos ::= SEQUENCE SIZE (1..MAX) OF Attribute
+     */
+    public class CryptoInfos
+        : Asn1Encodable
+    {
+        public static CryptoInfos GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is CryptoInfos cryptoInfos)
+                return cryptoInfos;
+            return new CryptoInfos(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static CryptoInfos GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new CryptoInfos(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly Asn1Sequence m_attributes;
+
+        private CryptoInfos(Asn1Sequence attributes)
+        {
+            m_attributes = attributes;
+        }
+
+        public CryptoInfos(Asn1.Cms.Attribute[] attrs)
+        {
+            m_attributes = new DerSequence(attrs);
+        }
+
+        public virtual Asn1.Cms.Attribute[] GetAttributes() => m_attributes.MapElements(Asn1.Cms.Attribute.GetInstance);
+
+        public override Asn1Object ToAsn1Object() => m_attributes;
+    }
+}
diff --git a/crypto/src/asn1/tsp/EncryptionInfo.cs b/crypto/src/asn1/tsp/EncryptionInfo.cs
new file mode 100644
index 000000000..e712c6a00
--- /dev/null
+++ b/crypto/src/asn1/tsp/EncryptionInfo.cs
@@ -0,0 +1,76 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of the EncryptionInfo element defined in RFC 4998:
+     * <p>
+     * 1988 ASN.1 EncryptionInfo
+     * <p>
+     * EncryptionInfo       ::=     SEQUENCE {
+     * encryptionInfoType     OBJECT IDENTIFIER,
+     * encryptionInfoValue    ANY DEFINED BY encryptionInfoType
+     * }
+     * <p>
+     * 1997-ASN.1 EncryptionInfo
+     * <p>
+     * EncryptionInfo       ::=     SEQUENCE {
+     * encryptionInfoType   ENCINFO-TYPE.&amp;id
+     * ({SupportedEncryptionAlgorithms}),
+     * encryptionInfoValue  ENCINFO-TYPE.&amp;Type
+     * ({SupportedEncryptionAlgorithms}{&#064;encryptionInfoType})
+     * }
+     * <p>
+     * ENCINFO-TYPE ::= TYPE-IDENTIFIER
+     * <p>
+     * SupportedEncryptionAlgorithms ENCINFO-TYPE ::= {...}
+     */
+    public class EncryptionInfo
+        : Asn1Encodable
+    {
+        public static EncryptionInfo GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is EncryptionInfo encryptionInfo)
+                return encryptionInfo;
+            return new EncryptionInfo(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static EncryptionInfo GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new EncryptionInfo(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        /**
+         * The OID for EncryptionInfo type.
+         */
+        private readonly DerObjectIdentifier m_encryptionInfoType;
+
+        /**
+         * The value of EncryptionInfo
+         */
+        private readonly Asn1Encodable m_encryptionInfoValue;
+
+        private EncryptionInfo(Asn1Sequence sequence)
+        {
+            if (sequence.Count != 2)
+                throw new ArgumentException("wrong sequence size in constructor: " + sequence.Count, nameof(sequence));
+
+            m_encryptionInfoType = DerObjectIdentifier.GetInstance(sequence[0]);
+            m_encryptionInfoValue = sequence[1];
+        }
+
+        public EncryptionInfo(DerObjectIdentifier encryptionInfoType, Asn1Encodable encryptionInfoValue)
+        {
+            m_encryptionInfoType = encryptionInfoType;
+            m_encryptionInfoValue = encryptionInfoValue;
+        }
+
+        public virtual DerObjectIdentifier EncryptionInfoType => m_encryptionInfoType;
+
+        public virtual Asn1Encodable EncryptionInfoValue => m_encryptionInfoValue;
+
+        public override Asn1Object ToAsn1Object() => new DLSequence(m_encryptionInfoType, m_encryptionInfoValue);
+    }
+}
diff --git a/crypto/src/asn1/tsp/EvidenceRecord.cs b/crypto/src/asn1/tsp/EvidenceRecord.cs
new file mode 100644
index 000000000..42ec4bf16
--- /dev/null
+++ b/crypto/src/asn1/tsp/EvidenceRecord.cs
@@ -0,0 +1,217 @@
+using System;
+
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * <a href="https://tools.ietf.org/html/rfc4998">RFC 4998</a>:
+     * Evidence Record Syntax (ERS)
+     * <p>
+     * <pre>
+     * EvidenceRecord ::= SEQUENCE {
+     *   version                   INTEGER { v1(1) } ,
+     *   digestAlgorithms          SEQUENCE OF AlgorithmIdentifier,
+     *   cryptoInfos               [0] CryptoInfos OPTIONAL,
+     *   encryptionInfo            [1] EncryptionInfo OPTIONAL,
+     *   archiveTimeStampSequence  ArchiveTimeStampSequence
+     * }
+     *
+     * CryptoInfos ::= SEQUENCE SIZE (1..MAX) OF Attribute
+     * </pre>
+     */
+    public class EvidenceRecord
+        : Asn1Encodable
+    {
+        /**
+         * ERS {iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) ltans(11)
+         * id-mod(0) id-mod-ers88(2) id-mod-ers88-v1(1) }
+         */
+        private static readonly DerObjectIdentifier Oid = new DerObjectIdentifier("1.3.6.1.5.5.11.0.2.1");
+
+        /**
+         * Return an EvidenceRecord from the given object.
+         *
+         * @param obj the object we want converted.
+         * @return an EvidenceRecord instance, or null.
+         * @throws IllegalArgumentException if the object cannot be converted.
+         */
+        public static EvidenceRecord GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is EvidenceRecord evidenceRecord)
+                return evidenceRecord;
+            return new EvidenceRecord(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static EvidenceRecord GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new EvidenceRecord(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly DerInteger m_version;
+        private readonly Asn1Sequence m_digestAlgorithms;
+        private readonly CryptoInfos m_cryptoInfos;
+        private readonly EncryptionInfo m_encryptionInfo;
+        private readonly ArchiveTimeStampSequence m_archiveTimeStampSequence;
+
+        private EvidenceRecord(EvidenceRecord evidenceRecord, ArchiveTimeStampSequence replacementSequence,
+            ArchiveTimeStamp newChainTimeStamp)
+        {
+            m_version = evidenceRecord.m_version;
+
+            // check the list of digest algorithms is correct.
+            if (newChainTimeStamp != null)
+            {
+                AlgorithmIdentifier algID = newChainTimeStamp.GetDigestAlgorithmIdentifier();
+                Asn1EncodableVector vector = new Asn1EncodableVector();
+
+                bool found = false;
+
+                foreach (var element in evidenceRecord.m_digestAlgorithms)
+                {
+                    AlgorithmIdentifier algorithmIdentifier = AlgorithmIdentifier.GetInstance(element);
+                    vector.Add(algorithmIdentifier);
+
+                    if (algorithmIdentifier.Equals(algID))
+                    {
+                        found = true;
+                        break;
+                    }
+                }
+
+                if (!found)
+                {
+                    vector.Add(algID);
+                    m_digestAlgorithms = new DerSequence(vector);
+                }
+                else
+                {
+                    m_digestAlgorithms = evidenceRecord.m_digestAlgorithms;
+                }
+            }
+            else
+            {
+                m_digestAlgorithms = evidenceRecord.m_digestAlgorithms;
+            }
+
+            m_cryptoInfos = evidenceRecord.m_cryptoInfos;
+            m_encryptionInfo = evidenceRecord.m_encryptionInfo;
+            m_archiveTimeStampSequence = replacementSequence;
+        }
+
+        /**
+         * Build a basic evidence record from an initial
+         * ArchiveTimeStamp.
+         * 
+         * @param cryptoInfos
+         * @param encryptionInfo
+         * @param archiveTimeStamp
+         */
+        public EvidenceRecord(CryptoInfos cryptoInfos, EncryptionInfo encryptionInfo, ArchiveTimeStamp archiveTimeStamp)
+        {
+            m_version = new DerInteger(1);
+            m_digestAlgorithms = new DerSequence(archiveTimeStamp.GetDigestAlgorithmIdentifier());
+            m_cryptoInfos = cryptoInfos;
+            m_encryptionInfo = encryptionInfo;
+            m_archiveTimeStampSequence = new ArchiveTimeStampSequence(new ArchiveTimeStampChain(archiveTimeStamp));
+        }
+
+        public EvidenceRecord(AlgorithmIdentifier[] digestAlgorithms, CryptoInfos cryptoInfos,
+            EncryptionInfo encryptionInfo, ArchiveTimeStampSequence archiveTimeStampSequence)
+        {
+            m_version = new DerInteger(1);
+            m_digestAlgorithms = new DerSequence(digestAlgorithms);
+            m_cryptoInfos = cryptoInfos;
+            m_encryptionInfo = encryptionInfo;
+            m_archiveTimeStampSequence = archiveTimeStampSequence;
+        }
+
+        private EvidenceRecord(Asn1Sequence sequence)
+        {
+            if (sequence.Count < 3 && sequence.Count > 5)
+                throw new ArgumentException("wrong sequence size in constructor: " + sequence.Count, nameof(sequence));
+
+            DerInteger versionNumber = DerInteger.GetInstance(sequence[0]);
+            if (!versionNumber.HasValue(1))
+                throw new ArgumentException("incompatible version");
+
+            m_version = versionNumber;
+
+            m_digestAlgorithms = Asn1Sequence.GetInstance(sequence[1]);
+            for (int i = 2; i != sequence.Count - 1; i++)
+            {
+                Asn1Encodable element = sequence[i];
+
+                if (element is Asn1TaggedObject asn1TaggedObject)
+                {
+                    switch (asn1TaggedObject.TagNo)
+                    {
+                    case 0:
+                        m_cryptoInfos = CryptoInfos.GetInstance(asn1TaggedObject, false);
+                        break;
+                    case 1:
+                        m_encryptionInfo = EncryptionInfo.GetInstance(asn1TaggedObject, false);
+                        break;
+                    default:
+                        throw new ArgumentException("unknown tag in GetInstance: " + asn1TaggedObject.TagNo);
+                    }
+                }
+                else
+                {
+                    throw new ArgumentException("unknown object in GetInstance: " + Platform.GetTypeName(element));
+                }
+            }
+            m_archiveTimeStampSequence = ArchiveTimeStampSequence.GetInstance(sequence[sequence.Count - 1]);
+        }
+
+        public virtual AlgorithmIdentifier[] GetDigestAlgorithms() =>
+            m_digestAlgorithms.MapElements(AlgorithmIdentifier.GetInstance);
+
+        public virtual ArchiveTimeStampSequence ArchiveTimeStampSequence => m_archiveTimeStampSequence;
+
+        /**
+         * Return a new EvidenceRecord with an added ArchiveTimeStamp
+         *
+         * @param ats         the archive timestamp to add
+         * @param newChain states whether this new archive timestamp must be added as part of a
+         *                    new sequence (i.e. in the case of hashtree renewal) or not (i.e. in the case of timestamp
+         *                    renewal)
+         * @return the new EvidenceRecord
+         */
+        public virtual EvidenceRecord AddArchiveTimeStamp(ArchiveTimeStamp ats, bool newChain)
+        {
+            if (newChain)
+            {
+                ArchiveTimeStampChain chain = new ArchiveTimeStampChain(ats);
+
+                return new EvidenceRecord(this, m_archiveTimeStampSequence.Append(chain), ats);
+            }
+            else
+            {
+                ArchiveTimeStampChain[] chains = m_archiveTimeStampSequence.GetArchiveTimeStampChains();
+
+                AlgorithmIdentifier digAlg = chains[chains.Length - 1].GetArchiveTimestamps()[0]
+                    .GetDigestAlgorithmIdentifier();
+                if (!digAlg.Equals(ats.GetDigestAlgorithmIdentifier()))
+                    throw new ArgumentException("mismatch of digest algorithm in AddArchiveTimeStamp");
+
+                chains[chains.Length - 1] = chains[chains.Length - 1].Append(ats);
+                return new EvidenceRecord(this, new ArchiveTimeStampSequence(chains), null);
+            }
+        }
+
+        public override Asn1Object ToAsn1Object()
+        {
+            Asn1EncodableVector vector = new Asn1EncodableVector(5);
+            vector.Add(m_version);
+            vector.Add(m_digestAlgorithms);
+            vector.AddOptionalTagged(false, 0, m_cryptoInfos);
+            vector.AddOptionalTagged(false, 1, m_encryptionInfo);
+            vector.Add(m_archiveTimeStampSequence);
+            return new DerSequence(vector);
+        }
+    }
+}
diff --git a/crypto/src/asn1/tsp/MessageImprint.cs b/crypto/src/asn1/tsp/MessageImprint.cs
index cb728629c..0be856048 100644
--- a/crypto/src/asn1/tsp/MessageImprint.cs
+++ b/crypto/src/asn1/tsp/MessageImprint.cs
@@ -8,46 +8,42 @@ namespace Org.BouncyCastle.Asn1.Tsp
 	public class MessageImprint
 		: Asn1Encodable
 	{
-		private readonly AlgorithmIdentifier	hashAlgorithm;
-		private readonly byte[]					hashedMessage;
-
         public static MessageImprint GetInstance(object obj)
         {
-            if (obj is MessageImprint)
-                return (MessageImprint)obj;
             if (obj == null)
                 return null;
+            if (obj is MessageImprint messageImprint)
+                return messageImprint;
             return new MessageImprint(Asn1Sequence.GetInstance(obj));
         }
 
-        private MessageImprint(
-			Asn1Sequence seq)
+		public static MessageImprint GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
 		{
-			if (seq.Count != 2)
-				throw new ArgumentException("Wrong number of elements in sequence", "seq");
+            return new MessageImprint(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
 
-			this.hashAlgorithm = AlgorithmIdentifier.GetInstance(seq[0]);
-			this.hashedMessage = Asn1OctetString.GetInstance(seq[1]).GetOctets();
-		}
+        private readonly AlgorithmIdentifier m_hashAlgorithm;
+        private readonly byte[] m_hashedMessage;
 
-		public MessageImprint(
-			AlgorithmIdentifier	hashAlgorithm,
-			byte[]				hashedMessage)
+        private MessageImprint(Asn1Sequence seq)
 		{
-			this.hashAlgorithm = hashAlgorithm;
-			this.hashedMessage = hashedMessage;
-		}
+			if (seq.Count != 2)
+				throw new ArgumentException("Wrong number of elements in sequence", nameof(seq));
 
-		public AlgorithmIdentifier HashAlgorithm
-		{
-			get { return hashAlgorithm; }
+			m_hashAlgorithm = AlgorithmIdentifier.GetInstance(seq[0]);
+			m_hashedMessage = Asn1OctetString.GetInstance(seq[1]).GetOctets();
 		}
 
-		public byte[] GetHashedMessage()
+		public MessageImprint(AlgorithmIdentifier hashAlgorithm, byte[] hashedMessage)
 		{
-			return hashedMessage;
+			m_hashAlgorithm = hashAlgorithm;
+			m_hashedMessage = hashedMessage;
 		}
 
+		public AlgorithmIdentifier HashAlgorithm => m_hashAlgorithm;
+
+		public byte[] GetHashedMessage() => m_hashedMessage;
+
 		/**
 		 * <pre>
 		 *    MessageImprint ::= SEQUENCE  {
@@ -57,7 +53,7 @@ namespace Org.BouncyCastle.Asn1.Tsp
 		 */
 		public override Asn1Object ToAsn1Object()
 		{
-			return new DerSequence(hashAlgorithm, new DerOctetString(hashedMessage));
+			return new DerSequence(m_hashAlgorithm, new DerOctetString(m_hashedMessage));
 		}
 	}
 }
diff --git a/crypto/src/asn1/tsp/PartialHashtree.cs b/crypto/src/asn1/tsp/PartialHashtree.cs
new file mode 100644
index 000000000..a32a9f18b
--- /dev/null
+++ b/crypto/src/asn1/tsp/PartialHashtree.cs
@@ -0,0 +1,91 @@
+using System;
+
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Collections;
+
+namespace Org.BouncyCastle.Asn1.Tsp
+{
+    /**
+     * Implementation of PartialHashtree, as defined in RFC 4998.
+     * <p>
+     * The ASN.1 notation for a PartialHashTree is:
+     * <p>
+     * PartialHashtree ::= SEQUENCE OF OCTET STRING
+     */
+    public class PartialHashtree
+        : Asn1Encodable
+    {
+        /**
+         * Return a PartialHashtree from the given object.
+         *
+         * @param obj the object we want converted.
+         * @return a PartialHashtree instance, or null.
+         * @throws IllegalArgumentException if the object cannot be converted.
+         */
+        public static PartialHashtree GetInstance(object obj)
+        {
+            if (obj == null)
+                return null;
+            if (obj is PartialHashtree partialHashtree)
+                return partialHashtree;
+            return new PartialHashtree(Asn1Sequence.GetInstance(obj));
+        }
+
+        public static PartialHashtree GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new PartialHashtree(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        /**
+         * Hash values that constitute the hash tree, as ASN.1 Octet Strings.
+         */
+        private readonly Asn1Sequence m_values;
+
+        private PartialHashtree(Asn1Sequence values)
+        {
+            for (int i = 0; i != values.Count; i++)
+            {
+                if (!(values[i] is Asn1OctetString))
+                    throw new ArgumentException("unknown object in constructor: " + Platform.GetTypeName(values[i]));
+            }
+            m_values = values;
+        }
+
+        public PartialHashtree(byte[] value)
+        {
+            m_values = new DerSequence(new DerOctetString(Arrays.Clone(value)));
+        }
+
+        public PartialHashtree(byte[][] values)
+        {
+            Asn1EncodableVector v = new Asn1EncodableVector(values.Length);
+
+            for (int i = 0; i != values.Length; i++)
+            {
+                v.Add(new DerOctetString(Arrays.Clone(values[i])));
+            }
+
+            m_values = new DerSequence(v);
+        }
+
+        public virtual int ValueCount => m_values.Count;
+
+        public virtual byte[][] GetValues() => m_values.MapElements(
+            element => Arrays.Clone(Asn1OctetString.GetInstance(element).GetOctets()));
+
+        public virtual bool ContainsHash(byte[] hash)
+        {
+            foreach (Asn1OctetString octetString in m_values)
+            {
+                byte[] currentHash = octetString.GetOctets();
+
+                if (Arrays.FixedTimeEquals(hash, currentHash))
+                    return true;
+            }
+
+            return false;
+        }
+
+        public override Asn1Object ToAsn1Object() => m_values;
+    }
+}
diff --git a/crypto/src/asn1/tsp/TSTInfo.cs b/crypto/src/asn1/tsp/TSTInfo.cs
index a8e166cbc..8aefe6159 100644
--- a/crypto/src/asn1/tsp/TSTInfo.cs
+++ b/crypto/src/asn1/tsp/TSTInfo.cs
@@ -7,25 +7,30 @@ namespace Org.BouncyCastle.Asn1.Tsp
 	public class TstInfo
 		: Asn1Encodable
 	{
-		private readonly DerInteger				version;
-		private readonly DerObjectIdentifier	tsaPolicyId;
-		private readonly MessageImprint			messageImprint;
-		private readonly DerInteger				serialNumber;
-		private readonly Asn1GeneralizedTime	genTime;
-		private readonly Accuracy				accuracy;
-		private readonly DerBoolean				ordering;
-		private readonly DerInteger				nonce;
-		private readonly GeneralName			tsa;
-		private readonly X509Extensions			extensions;
-
-		public static TstInfo GetInstance(object obj)
-		{
-            if (obj is TstInfo)
-                return (TstInfo)obj;
+        public static TstInfo GetInstance(object obj)
+        {
             if (obj == null)
                 return null;
+            if (obj is TstInfo tstInfo)
+                return tstInfo;
             return new TstInfo(Asn1Sequence.GetInstance(obj));
-		}
+        }
+
+        public static TstInfo GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+        {
+            return new TstInfo(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly DerInteger m_version;
+		private readonly DerObjectIdentifier m_tsaPolicyID;
+		private readonly MessageImprint m_messageImprint;
+		private readonly DerInteger m_serialNumber;
+		private readonly Asn1GeneralizedTime m_genTime;
+		private readonly Accuracy m_accuracy;
+		private readonly DerBoolean m_ordering;
+		private readonly DerInteger m_nonce;
+		private readonly GeneralName m_tsa;
+		private readonly X509Extensions m_extensions;
 
 		private TstInfo(Asn1Sequence seq)
 		{
@@ -33,26 +38,26 @@ namespace Org.BouncyCastle.Asn1.Tsp
 
 			// version
 			e.MoveNext();
-			version = DerInteger.GetInstance(e.Current);
+			m_version = DerInteger.GetInstance(e.Current);
 
 			// tsaPolicy
 			e.MoveNext();
-			tsaPolicyId = DerObjectIdentifier.GetInstance(e.Current);
+			m_tsaPolicyID = DerObjectIdentifier.GetInstance(e.Current);
 
 			// messageImprint
 			e.MoveNext();
-			messageImprint = MessageImprint.GetInstance(e.Current);
+			m_messageImprint = MessageImprint.GetInstance(e.Current);
 
 			// serialNumber
 			e.MoveNext();
-			serialNumber = DerInteger.GetInstance(e.Current);
+			m_serialNumber = DerInteger.GetInstance(e.Current);
 
 			// genTime
 			e.MoveNext();
-			genTime = Asn1GeneralizedTime.GetInstance(e.Current);
+			m_genTime = Asn1GeneralizedTime.GetInstance(e.Current);
 
 			// default for ordering
-			ordering = DerBoolean.False;
+			m_ordering = DerBoolean.False;
 
 			while (e.MoveNext())
 			{
@@ -63,10 +68,10 @@ namespace Org.BouncyCastle.Asn1.Tsp
 					switch (tagged.TagNo)
 					{
 					case 0:
-						tsa = GeneralName.GetInstance(tagged, true);
+						m_tsa = GeneralName.GetInstance(tagged, true);
 						break;
 					case 1:
-						extensions = X509Extensions.GetInstance(tagged, false);
+						m_extensions = X509Extensions.GetInstance(tagged, false);
 						break;
 					default:
 						throw new ArgumentException("Unknown tag value " + tagged.TagNo);
@@ -75,95 +80,58 @@ namespace Org.BouncyCastle.Asn1.Tsp
 
 				if (o is Asn1Sequence)
 				{
-					accuracy = Accuracy.GetInstance(o);
+					m_accuracy = Accuracy.GetInstance(o);
 				}
 
 				if (o is DerBoolean)
 				{
-					ordering = DerBoolean.GetInstance(o);
+					m_ordering = DerBoolean.GetInstance(o);
 				}
 
 				if (o is DerInteger)
 				{
-					nonce = DerInteger.GetInstance(o);
+					m_nonce = DerInteger.GetInstance(o);
 				}
 			}
 		}
 
-		public TstInfo(
-			DerObjectIdentifier	tsaPolicyId,
-			MessageImprint		messageImprint,
-			DerInteger			serialNumber,
-            Asn1GeneralizedTime genTime,
-			Accuracy			accuracy,
-			DerBoolean			ordering,
-			DerInteger			nonce,
-			GeneralName			tsa,
-			X509Extensions		extensions)
-		{
-			this.version = new DerInteger(1);
-			this.tsaPolicyId = tsaPolicyId;
-			this.messageImprint = messageImprint;
-			this.serialNumber = serialNumber;
-			this.genTime = genTime;
-			this.accuracy = accuracy;
-			this.ordering = ordering;
-			this.nonce = nonce;
-			this.tsa = tsa;
-			this.extensions = extensions;
-		}
-
-        public DerInteger Version
+        public TstInfo(DerObjectIdentifier tsaPolicyId, MessageImprint messageImprint, DerInteger serialNumber,
+            Asn1GeneralizedTime genTime, Accuracy accuracy, DerBoolean ordering, DerInteger nonce, GeneralName tsa,
+            X509Extensions extensions)
         {
-            get { return version; }
+            m_version = new DerInteger(1);
+            m_tsaPolicyID = tsaPolicyId;
+            m_messageImprint = messageImprint;
+            m_serialNumber = serialNumber;
+            m_genTime = genTime;
+            m_accuracy = accuracy;
+            m_ordering = ordering;
+            m_nonce = nonce;
+            m_tsa = tsa;
+            m_extensions = extensions;
         }
 
-		public MessageImprint MessageImprint
-		{
-			get { return messageImprint; }
-		}
+        public DerInteger Version => m_version;
 
-		public DerObjectIdentifier Policy
-		{
-			get { return tsaPolicyId; }
-		}
+        public MessageImprint MessageImprint => m_messageImprint;
 
-		public DerInteger SerialNumber
-		{
-			get { return serialNumber; }
-		}
+        public DerObjectIdentifier Policy => m_tsaPolicyID;
 
-		public Accuracy Accuracy
-		{
-			get { return accuracy; }
-		}
+        public DerInteger SerialNumber => m_serialNumber;
 
-		public Asn1GeneralizedTime GenTime
-		{
-			get { return genTime; }
-		}
+        public Accuracy Accuracy => m_accuracy;
 
-		public DerBoolean Ordering
-		{
-			get { return ordering; }
-		}
+        public Asn1GeneralizedTime GenTime => m_genTime;
 
-		public DerInteger Nonce
-		{
-			get { return nonce; }
-		}
+        public DerBoolean Ordering => m_ordering;
 
-		public GeneralName Tsa
-		{
-			get { return tsa; }
-		}
+        public DerInteger Nonce => m_nonce;
 
-		public X509Extensions Extensions
-		{
-			get { return extensions; }
-		}
+        public GeneralName Tsa => m_tsa;
+
+        public X509Extensions Extensions => m_extensions;
 
-		/**
+        /**
 		 * <pre>
 		 *
 		 *     TstInfo ::= SEQUENCE  {
@@ -188,18 +156,19 @@ namespace Org.BouncyCastle.Asn1.Tsp
 		 */
         public override Asn1Object ToAsn1Object()
         {
-            Asn1EncodableVector v = new Asn1EncodableVector(version, tsaPolicyId, messageImprint, serialNumber, genTime);
-            v.AddOptional(accuracy);
+            Asn1EncodableVector v = new Asn1EncodableVector(10);
+            v.Add(m_version, m_tsaPolicyID, m_messageImprint, m_serialNumber, m_genTime);
+            v.AddOptional(m_accuracy);
 
-            if (ordering != null && ordering.IsTrue)
+            if (m_ordering != null && m_ordering.IsTrue)
             {
-                v.Add(ordering);
+                v.Add(m_ordering);
             }
 
-            v.AddOptional(nonce);
-            v.AddOptionalTagged(true, 0, tsa);
-            v.AddOptionalTagged(false, 1, extensions);
+            v.AddOptional(m_nonce);
+            v.AddOptionalTagged(true, 0, m_tsa);
+            v.AddOptionalTagged(false, 1, m_extensions);
             return new DerSequence(v);
         }
-	}
+    }
 }
diff --git a/crypto/src/asn1/tsp/TimeStampReq.cs b/crypto/src/asn1/tsp/TimeStampReq.cs
index 027c0a45b..6b3afd553 100644
--- a/crypto/src/asn1/tsp/TimeStampReq.cs
+++ b/crypto/src/asn1/tsp/TimeStampReq.cs
@@ -8,107 +8,90 @@ namespace Org.BouncyCastle.Asn1.Tsp
 	public class TimeStampReq
 		: Asn1Encodable
 	{
-		private readonly DerInteger				version;
-		private readonly MessageImprint			messageImprint;
-		private readonly DerObjectIdentifier	tsaPolicy;
-		private readonly DerInteger				nonce;
-		private readonly DerBoolean				certReq;
-		private readonly X509Extensions			extensions;
+		private readonly DerInteger m_version;
+		private readonly MessageImprint m_messageImprint;
+		private readonly DerObjectIdentifier m_tsaPolicy;
+		private readonly DerInteger m_nonce;
+		private readonly DerBoolean m_certReq;
+		private readonly X509Extensions m_extensions;
 
         public static TimeStampReq GetInstance(object obj)
         {
-            if (obj is TimeStampReq)
-                return (TimeStampReq)obj;
             if (obj == null)
                 return null;
+            if (obj is TimeStampReq timeStampReq)
+                return timeStampReq;
             return new TimeStampReq(Asn1Sequence.GetInstance(obj));
         }
 
+		public static TimeStampReq GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+		{
+            return new TimeStampReq(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
         private TimeStampReq(Asn1Sequence seq)
 		{
 			int nbObjects = seq.Count;
 			int seqStart = 0;
 
 			// version
-			version = DerInteger.GetInstance(seq[seqStart++]);
+			m_version = DerInteger.GetInstance(seq[seqStart++]);
 
 			// messageImprint
-			messageImprint = MessageImprint.GetInstance(seq[seqStart++]);
+			m_messageImprint = MessageImprint.GetInstance(seq[seqStart++]);
 
 			for (int opt = seqStart; opt < nbObjects; opt++)
 			{
 				// tsaPolicy
 				if (seq[opt] is DerObjectIdentifier oid)
 				{
-					tsaPolicy = oid;
+					m_tsaPolicy = oid;
 				}
 				// nonce
 				else if (seq[opt] is DerInteger derInteger)
 				{
-					nonce = derInteger;
+					m_nonce = derInteger;
 				}
 				// certReq
 				else if (seq[opt] is DerBoolean derBoolean)
 				{
-					certReq = derBoolean;
+					m_certReq = derBoolean;
 				}
 				// extensions
 				else if (seq[opt] is Asn1TaggedObject tagged)
 				{
 					if (tagged.TagNo == 0)
 					{
-						extensions = X509Extensions.GetInstance(tagged, false);
+						m_extensions = X509Extensions.GetInstance(tagged, false);
 					}
 				}
 			}
 		}
 
-		public TimeStampReq(
-			MessageImprint		messageImprint,
-			DerObjectIdentifier	tsaPolicy,
-			DerInteger			nonce,
-			DerBoolean			certReq,
-			X509Extensions		extensions)
-		{
-			// default
-			this.version = new DerInteger(1);
-
-			this.messageImprint = messageImprint;
-			this.tsaPolicy = tsaPolicy;
-			this.nonce = nonce;
-			this.certReq = certReq;
-			this.extensions = extensions;
-		}
+        public TimeStampReq(MessageImprint messageImprint, DerObjectIdentifier tsaPolicy, DerInteger nonce,
+            DerBoolean certReq, X509Extensions extensions)
+        {
+            // default
+            m_version = new DerInteger(1);
+
+            m_messageImprint = messageImprint;
+            m_tsaPolicy = tsaPolicy;
+            m_nonce = nonce;
+            m_certReq = certReq;
+            m_extensions = extensions;
+        }
 
-		public DerInteger Version
-		{
-			get { return version; }
-		}
+		public DerInteger Version => m_version;
 
-		public MessageImprint MessageImprint
-		{
-			get { return messageImprint; }
-		}
+		public MessageImprint MessageImprint => m_messageImprint;
 
-		public DerObjectIdentifier ReqPolicy
-		{
-			get { return tsaPolicy; }
-		}
+		public DerObjectIdentifier ReqPolicy => m_tsaPolicy;
 
-		public DerInteger Nonce
-		{
-			get { return nonce; }
-		}
+		public DerInteger Nonce => m_nonce;
 
-		public DerBoolean CertReq
-		{
-			get { return certReq; }
-		}
+		public DerBoolean CertReq => m_certReq;
 
-		public X509Extensions Extensions
-		{
-			get { return extensions; }
-		}
+		public X509Extensions Extensions => m_extensions;
 
 		/**
 		 * <pre>
@@ -126,15 +109,16 @@ namespace Org.BouncyCastle.Asn1.Tsp
 		 */
         public override Asn1Object ToAsn1Object()
         {
-            Asn1EncodableVector v = new Asn1EncodableVector(version, messageImprint);
-            v.AddOptional(tsaPolicy, nonce);
+            Asn1EncodableVector v = new Asn1EncodableVector(6);
+			v.Add(m_version, m_messageImprint);
+            v.AddOptional(m_tsaPolicy, m_nonce);
 
-            if (certReq != null && certReq.IsTrue)
+            if (m_certReq != null && m_certReq.IsTrue)
             {
-                v.Add(certReq);
+                v.Add(m_certReq);
             }
 
-            v.AddOptionalTagged(false, 0, extensions);
+            v.AddOptionalTagged(false, 0, m_extensions);
             return new DerSequence(v);
         }
 	}
diff --git a/crypto/src/asn1/tsp/TimeStampResp.cs b/crypto/src/asn1/tsp/TimeStampResp.cs
index 3dde0dfce..cc9c2ed4d 100644
--- a/crypto/src/asn1/tsp/TimeStampResp.cs
+++ b/crypto/src/asn1/tsp/TimeStampResp.cs
@@ -9,46 +9,42 @@ namespace Org.BouncyCastle.Asn1.Tsp
 	public class TimeStampResp
 		: Asn1Encodable
 	{
-		private readonly PkiStatusInfo	pkiStatusInfo;
-		private readonly ContentInfo	timeStampToken;
-
         public static TimeStampResp GetInstance(object obj)
         {
-            if (obj is TimeStampResp)
-                return (TimeStampResp)obj;
             if (obj == null)
                 return null;
+            if (obj is TimeStampResp timeStampResp)
+                return timeStampResp;
             return new TimeStampResp(Asn1Sequence.GetInstance(obj));
         }
 
-        private TimeStampResp(
-			Asn1Sequence seq)
+		public static TimeStampResp GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
+		{
+            return new TimeStampResp(Asn1Sequence.GetInstance(taggedObject, declaredExplicit));
+        }
+
+        private readonly PkiStatusInfo m_pkiStatusInfo;
+        private readonly ContentInfo m_timeStampToken;
+
+        private TimeStampResp(Asn1Sequence seq)
 		{
-			this.pkiStatusInfo = PkiStatusInfo.GetInstance(seq[0]);
+			m_pkiStatusInfo = PkiStatusInfo.GetInstance(seq[0]);
 
 			if (seq.Count > 1)
 			{
-				this.timeStampToken = ContentInfo.GetInstance(seq[1]);
+				m_timeStampToken = ContentInfo.GetInstance(seq[1]);
 			}
 		}
 
-		public TimeStampResp(
-			PkiStatusInfo	pkiStatusInfo,
-			ContentInfo		timeStampToken)
+		public TimeStampResp(PkiStatusInfo pkiStatusInfo, ContentInfo timeStampToken)
 		{
-			this.pkiStatusInfo = pkiStatusInfo;
-			this.timeStampToken = timeStampToken;
+			m_pkiStatusInfo = pkiStatusInfo;
+			m_timeStampToken = timeStampToken;
 		}
 
-		public PkiStatusInfo Status
-		{
-			get { return pkiStatusInfo; }
-		}
+		public PkiStatusInfo Status => m_pkiStatusInfo;
 
-		public ContentInfo TimeStampToken
-		{
-			get { return timeStampToken; }
-		}
+		public ContentInfo TimeStampToken => m_timeStampToken;
 
 		/**
 		 * <pre>
@@ -59,8 +55,9 @@ namespace Org.BouncyCastle.Asn1.Tsp
 		 */
         public override Asn1Object ToAsn1Object()
         {
-            Asn1EncodableVector v = new Asn1EncodableVector(pkiStatusInfo);
-            v.AddOptional(timeStampToken);
+            Asn1EncodableVector v = new Asn1EncodableVector(2);
+			v.Add(m_pkiStatusInfo);
+            v.AddOptional(m_timeStampToken);
             return new DerSequence(v);
         }
 	}