Reimplement application-specific over tagged object

12 files changed, 514 insertions, 356 deletions

diff --git a/crypto/BouncyCastle.Android.csproj b/crypto/BouncyCastle.Android.csproj
index 0cececb3f..c3d897efb 100644
--- a/crypto/BouncyCastle.Android.csproj
+++ b/crypto/BouncyCastle.Android.csproj
@@ -132,6 +132,7 @@
     <Compile Include="src\asn1\DerUniversalString.cs" />
     <Compile Include="src\asn1\DerVideotexString.cs" />
     <Compile Include="src\asn1\DerVisibleString.cs" />
+    <Compile Include="src\asn1\DLApplicationSpecific.cs" />
     <Compile Include="src\asn1\DLSequence.cs" />
     <Compile Include="src\asn1\DLSet.cs" />
     <Compile Include="src\asn1\DLTaggedObject.cs" />
diff --git a/crypto/BouncyCastle.csproj b/crypto/BouncyCastle.csproj
index 2e82e2432..0ffedcb1a 100644
--- a/crypto/BouncyCastle.csproj
+++ b/crypto/BouncyCastle.csproj
@@ -126,6 +126,7 @@
     <Compile Include="src\asn1\DerUniversalString.cs" />
     <Compile Include="src\asn1\DerVideotexString.cs" />
     <Compile Include="src\asn1\DerVisibleString.cs" />
+    <Compile Include="src\asn1\DLApplicationSpecific.cs" />
     <Compile Include="src\asn1\DLSequence.cs" />
     <Compile Include="src\asn1\DLSet.cs" />
     <Compile Include="src\asn1\DLTaggedObject.cs" />
diff --git a/crypto/BouncyCastle.iOS.csproj b/crypto/BouncyCastle.iOS.csproj
index 29031b947..3cd17d407 100644
--- a/crypto/BouncyCastle.iOS.csproj
+++ b/crypto/BouncyCastle.iOS.csproj
@@ -127,6 +127,7 @@
     <Compile Include="src\asn1\DerUniversalString.cs" />
     <Compile Include="src\asn1\DerVideotexString.cs" />
     <Compile Include="src\asn1\DerVisibleString.cs" />
+    <Compile Include="src\asn1\DLApplicationSpecific.cs" />
     <Compile Include="src\asn1\DLSequence.cs" />
     <Compile Include="src\asn1\DLSet.cs" />
     <Compile Include="src\asn1\DLTaggedObject.cs" />
diff --git a/crypto/crypto.csproj b/crypto/crypto.csproj
index b490065e0..870cafbe9 100644
--- a/crypto/crypto.csproj
+++ b/crypto/crypto.csproj
@@ -519,6 +519,11 @@
                     BuildAction = "Compile"
                 />
                 <File
+                    RelPath = "src\asn1\DLApplicationSpecific.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
                     RelPath = "src\asn1\DLSequence.cs"
                     SubType = "Code"
                     BuildAction = "Compile"
diff --git a/crypto/src/asn1/Asn1TaggedObject.cs b/crypto/src/asn1/Asn1TaggedObject.cs
index aaa719ecc..13d1ff283 100644
--- a/crypto/src/asn1/Asn1TaggedObject.cs
+++ b/crypto/src/asn1/Asn1TaggedObject.cs
@@ -13,18 +13,13 @@ namespace Org.BouncyCastle.Asn1
     public abstract class Asn1TaggedObject
 		: Asn1Object, Asn1TaggedObjectParser
     {
-        // TODO[asn1] Rewrite DerApplicationSpecific in terms of Asn1TaggedObject and remove this
-        internal static bool IsConstructed(bool isExplicit, Asn1Object obj)
-        {
-            if (isExplicit || obj is Asn1Sequence || obj is Asn1Set)
-                return true;
-            Asn1TaggedObject tagged = obj as Asn1TaggedObject;
-            if (tagged == null)
-                return false;
-            return IsConstructed(tagged.IsExplicit(), tagged.GetObject());
-        }
+        private const int DeclaredExplicit = 1;
+        private const int DeclaredImplicit = 2;
+        // TODO It will probably be better to track parsing constructed vs primitive instead
+        private const int ParsedExplicit = 3;
+        private const int ParsedImplicit = 4;
 
-		public static Asn1TaggedObject GetInstance(object obj)
+        public static Asn1TaggedObject GetInstance(object obj)
 		{
             if (obj == null || obj is Asn1TaggedObject) 
             {
@@ -57,69 +52,91 @@ namespace Org.BouncyCastle.Asn1
             if (Asn1Tags.ContextSpecific != taggedObject.TagClass)
                 throw new InvalidOperationException("this method only valid for CONTEXT_SPECIFIC tags");
 
-            if (!declaredExplicit)
-                throw new ArgumentException("this method not valid for implicitly tagged tagged objects");
+            if (declaredExplicit)
+                return taggedObject.GetExplicitBaseTagged();
 
-            return taggedObject.GetExplicitBaseTagged();
+            throw new ArgumentException("this method not valid for implicitly tagged tagged objects");
         }
 
-        internal readonly int tagClass = Asn1Tags.ContextSpecific;
+        internal readonly int explicitness;
+        internal readonly int tagClass;
         internal readonly int tagNo;
-        internal readonly bool explicitly;
         internal readonly Asn1Encodable obj;
 
-        /**
+		/**
+         * @param explicitly true if the object is explicitly tagged.
          * @param tagNo the tag number for this object.
          * @param obj the tagged object.
          */
-        protected Asn1TaggedObject(int tagNo, Asn1Encodable obj)
-            : this(true, tagNo, obj)
+        protected Asn1TaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+            : this(isExplicit, Asn1Tags.ContextSpecific, tagNo, obj)
         {
         }
 
-		/**
-         * @param explicitly true if the object is explicitly tagged.
-         * @param tagNo the tag number for this object.
-         * @param obj the tagged object.
-         */
-        protected Asn1TaggedObject(bool explicitly, int tagNo, Asn1Encodable obj)
+        protected Asn1TaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : this(isExplicit ? DeclaredExplicit : DeclaredImplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal Asn1TaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
         {
             if (null == obj)
                 throw new ArgumentNullException("obj");
+            if (Asn1Tags.Universal == tagClass || (tagClass & Asn1Tags.Private) != tagClass)
+                throw new ArgumentException("invalid tag class: " + tagClass, "tagClass");
 
-            // IAsn1Choice marker interface 'insists' on explicit tagging
-            this.explicitly = explicitly || (obj is IAsn1Choice);
+            this.explicitness = (obj is IAsn1Choice) ? DeclaredExplicit : explicitness;
+            this.tagClass = tagClass;
             this.tagNo = tagNo;
             this.obj = obj;
         }
 
-		protected override bool Asn1Equals(Asn1Object asn1Object)
+        protected override bool Asn1Equals(Asn1Object asn1Object)
         {
             if (asn1Object is DerApplicationSpecific)
                 return asn1Object.CallAsn1Equals(this);
 
             Asn1TaggedObject that = asn1Object as Asn1TaggedObject;
-            return null != that
-                && this.tagClass == that.tagClass
-                && this.tagNo == that.tagNo
-                && this.explicitly == that.explicitly   // TODO Should this be part of equality?
-                && this.GetObject().Equals(that.GetObject());
-		}
+            if (null == that || this.tagNo != that.tagNo || this.tagClass != that.tagClass)
+                return false;
 
-		protected override int Asn1GetHashCode()
-		{
-            int code = (tagClass * 7919) ^ tagNo;
+            if (this.explicitness != that.explicitness)
+            {
+                /*
+                 * TODO This seems incorrect for some cases of implicit tags e.g. if one is a
+                 * declared-implicit SET and the other a parsed object.
+                 */
+                if (this.IsExplicit() != that.IsExplicit())
+                    return false;
+            }
 
-			// TODO: actually this is wrong - the problem is that a re-encoded
-			// object may end up with a different hashCode due to implicit
-			// tagging. As implicit tagging is ambiguous if a sequence is involved
-			// it seems the only correct method for both equals and hashCode is to
-			// compare the encodings...
-//			code ^= explicitly.GetHashCode();
+            Asn1Object p1 = this.obj.ToAsn1Object();
+            Asn1Object p2 = that.obj.ToAsn1Object();
 
-            code ^= obj.GetHashCode();
+            if (p1 == p2)
+                return true;
+
+            if (!this.IsExplicit())
+            {
+                try
+                {
+                    byte[] d1 = this.GetEncoded();
+                    byte[] d2 = that.GetEncoded();
 
-			return code;
+                    return Arrays.AreEqual(d1, d2);
+                }
+                catch (IOException)
+                {
+                    return false;
+                }
+            }
+
+            return p1.CallAsn1Equals(p2);
+		}
+
+		protected override int Asn1GetHashCode()
+		{
+            return (tagClass * 7919) ^ tagNo ^ (IsExplicit() ? 0x0F : 0xF0) ^ obj.ToAsn1Object().CallAsn1GetHashCode();
         }
 
         public int TagClass
@@ -142,6 +159,12 @@ namespace Org.BouncyCastle.Asn1
             return this.tagClass == tagClass && this.tagNo == tagNo;
         }
 
+        [Obsolete("Will be removed. Replace with constant return value of 'false'")]
+        public bool IsEmpty()
+        {
+            return false;
+        }
+
         /**
          * return whether or not the object may be explicitly tagged.
          * <p>
@@ -153,13 +176,27 @@ namespace Org.BouncyCastle.Asn1
          */
         public bool IsExplicit()
         {
-            return explicitly;
+            // TODO New methods like 'IsKnownExplicit' etc. to distinguish uncertain cases?
+            switch (explicitness)
+            {
+            case DeclaredExplicit:
+            case ParsedExplicit:
+                return true;
+            default:
+                return false;
+            }
         }
 
-        [Obsolete("Will be removed. Replace with constant return value of 'false'")]
-        public bool IsEmpty()
+        internal bool IsParsed()
         {
-            return false;
+            switch (explicitness)
+            {
+            case ParsedExplicit:
+            case ParsedImplicit:
+                return true;
+            default:
+                return false;
+            }
         }
 
         /**
@@ -198,6 +235,18 @@ namespace Org.BouncyCastle.Asn1
         }
 
         /**
+         * Return true if the object is marked as constructed, false otherwise.
+         *
+         * @return true if constructed, otherwise false.
+         */
+        // TODO Need this public if/when DerApplicationSpecific extends Asn1TaggedObject
+        internal bool IsConstructed()
+        {
+            int encoding = Asn1Encoding == Ber ? Asn1OutputStream.EncodingBer : Asn1OutputStream.EncodingDer;
+            return EncodeConstructed(encoding);
+        }
+
+        /**
          * return whatever was following the tag.
          * <p>
          * Note: tagged objects are generally context dependent if you're
@@ -245,6 +294,34 @@ namespace Org.BouncyCastle.Asn1
             return CheckedCast(obj.ToAsn1Object());
         }
 
+        public Asn1TaggedObject GetImplicitBaseTagged(int baseTagClass, int baseTagNo)
+        {
+            if (Asn1Tags.Universal == baseTagClass || (baseTagClass & Asn1Tags.Private) != baseTagClass)
+                throw new ArgumentException("invalid base tag class: " + baseTagClass, "baseTagClass");
+
+            switch (explicitness)
+            {
+            case DeclaredExplicit:
+                throw new InvalidOperationException("object explicit - implicit expected.");
+
+            case DeclaredImplicit:
+            {
+                Asn1TaggedObject declared = CheckedCast(obj.ToAsn1Object());
+                if (!declared.HasTag(baseTagClass, baseTagNo))
+                {
+                    string expected = Asn1Utilities.GetTagText(baseTagClass, baseTagNo);
+                    string found = Asn1Utilities.GetTagText(declared);
+                    throw new InvalidOperationException("Expected " + expected + " tag but found " + found);
+                }
+                return declared;
+            }
+
+            // Parsed; return a virtual tag (i.e. that couldn't have been present in the encoding)
+            default:
+                return ReplaceTag(baseTagClass, baseTagNo);
+            }
+        }
+
         /**
 		* Return the object held in this tagged object as a parser assuming it has
 		* the type of the passed in tag. If the object doesn't have a parser
@@ -267,10 +344,8 @@ namespace Org.BouncyCastle.Asn1
 				return Asn1Set.GetInstance(this, isExplicit).Parser;
 			}
 
-			if (isExplicit)
-			{
-				return GetObject();
-			}
+            if (isExplicit)
+                return obj.ToAsn1Object();
 
 			throw Platform.CreateNotImplementedException("implicit tagging for tag: " + tag);
 		}
@@ -284,6 +359,8 @@ namespace Org.BouncyCastle.Asn1
 
         internal abstract Asn1Sequence RebuildConstructed(Asn1Object asn1Object);
 
+        internal abstract Asn1TaggedObject ReplaceTag(int tagClass, int tagNo);
+
         internal static Asn1Object CreateConstructed(int tagClass, int tagNo, bool isIL,
             Asn1EncodableVector contentsElements)
         {
@@ -291,29 +368,47 @@ namespace Org.BouncyCastle.Asn1
 
             if (isIL)
             {
-                if (Asn1Tags.Application == tagClass)
-                    return new BerApplicationSpecific(tagNo, contentsElements);
+                Asn1TaggedObject taggedObject = maybeExplicit
+                    ?   new BerTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+                    :   new BerTaggedObject(ParsedImplicit, tagClass, tagNo, BerSequence.FromVector(contentsElements));
 
-                return maybeExplicit
-                    ? new BerTaggedObject(true, tagNo, contentsElements[0])
-                    : new BerTaggedObject(false, tagNo, BerSequence.FromVector(contentsElements));
+                switch (tagClass)
+                {
+                case Asn1Tags.Application:
+                    return new BerApplicationSpecific(taggedObject);
+                default:
+                    return taggedObject;
+                }
             }
+            else
+            {
+                Asn1TaggedObject taggedObject = maybeExplicit
+                    ?   new DLTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+                    :   new DLTaggedObject(ParsedImplicit, tagClass, tagNo, DLSequence.FromVector(contentsElements));
 
-            if (Asn1Tags.Application == tagClass)
-                return new DerApplicationSpecific(tagNo, contentsElements);
-
-            return maybeExplicit
-                ? new DLTaggedObject(true, tagNo, contentsElements[0])
-                : new DLTaggedObject(false, tagNo, DLSequence.FromVector(contentsElements));
+                switch (tagClass)
+                {
+                case Asn1Tags.Application:
+                    return new DLApplicationSpecific(taggedObject);
+                default:
+                    return taggedObject;
+                }
+            }
         }
 
         internal static Asn1Object CreatePrimitive(int tagClass, int tagNo, byte[] contentsOctets)
         {
             // Note: !CONSTRUCTED => IMPLICIT
-            if (Asn1Tags.Application == tagClass)
-                return new DerApplicationSpecific(false, tagNo, contentsOctets);
+            Asn1TaggedObject taggedObject = new DLTaggedObject(ParsedImplicit, tagClass, tagNo,
+                new DerOctetString(contentsOctets));
 
-            return new DLTaggedObject(false, tagNo, new DerOctetString(contentsOctets));
+            switch (tagClass)
+            {
+            case Asn1Tags.Application:
+                return new DLApplicationSpecific(taggedObject);
+            default:
+                return taggedObject;
+            }
         }
 
         private static Asn1TaggedObject CheckedCast(Asn1Object asn1Object)
diff --git a/crypto/src/asn1/BerApplicationSpecific.cs b/crypto/src/asn1/BerApplicationSpecific.cs
index 65fbecbe1..2a874984f 100644
--- a/crypto/src/asn1/BerApplicationSpecific.cs
+++ b/crypto/src/asn1/BerApplicationSpecific.cs
@@ -5,11 +5,43 @@ namespace Org.BouncyCastle.Asn1
 	public class BerApplicationSpecific
 		: DerApplicationSpecific
 	{
-		public BerApplicationSpecific(
-			int					tagNo,
-			Asn1EncodableVector	vec)
-			: base(tagNo, vec)
-		{
-		}
+        /**
+         * Create an application specific object with an explicit tag
+         *
+         * @param tagNo the tag number for this object.
+         * @param baseEncodable the object to be contained.
+         */
+        public BerApplicationSpecific(int tagNo, Asn1Encodable baseEncodable)
+            : this(true, tagNo, baseEncodable)
+        {
+        }
+
+        /**
+         * Create an application specific object with the tagging style given by the value of explicit.
+         *
+         * @param explicit true if the object is explicitly tagged.
+         * @param tagNo the tag number for this object.
+         * @param baseEncodable the object to be contained.
+         */
+        public BerApplicationSpecific(bool isExplicit, int tagNo, Asn1Encodable baseEncodable)
+            : base(new BerTaggedObject(isExplicit, Asn1Tags.Application, tagNo, baseEncodable))
+        {
+        }
+
+        /**
+         * Create an application specific object which is marked as constructed
+         *
+         * @param tagNo the tag number for this object.
+         * @param contentsElements the objects making up the application specific object.
+         */
+        public BerApplicationSpecific(int tagNo, Asn1EncodableVector contentsElements)
+            : base(new BerTaggedObject(false, Asn1Tags.Application, tagNo, BerSequence.FromVector(contentsElements)))
+        {
+        }
+
+        internal BerApplicationSpecific(Asn1TaggedObject taggedObject)
+            : base(taggedObject)
+        {
+        }
 	}
 }
diff --git a/crypto/src/asn1/BerTaggedObject.cs b/crypto/src/asn1/BerTaggedObject.cs
index fc4d1835a..a97a8e143 100644
--- a/crypto/src/asn1/BerTaggedObject.cs
+++ b/crypto/src/asn1/BerTaggedObject.cs
@@ -10,39 +10,49 @@ namespace Org.BouncyCastle.Asn1
 	public class BerTaggedObject
 		: DerTaggedObject
 	{
-		/**
+        /**
+		 * create an implicitly tagged object that contains a zero
+		 * length sequence.
+		 */
+        [Obsolete("Will be removed")]
+        public BerTaggedObject(int tagNo)
+            : base(false, tagNo, BerSequence.Empty)
+        {
+        }
+
+        /**
 		 * @param tagNo the tag number for this object.
 		 * @param obj the tagged object.
 		 */
-		public BerTaggedObject(
-			int				tagNo,
-			Asn1Encodable	obj)
-			: base(tagNo, obj)
+        public BerTaggedObject(int tagNo, Asn1Encodable obj)
+			: base(true, tagNo, obj)
 		{
 		}
 
-		/**
-		 * @param explicitly true if an explicitly tagged object.
+        public BerTaggedObject(int tagClass, int tagNo, Asn1Encodable obj)
+            : base(true, tagClass, tagNo, obj)
+        {
+        }
+
+        /**
+		 * @param isExplicit true if an explicitly tagged object.
 		 * @param tagNo the tag number for this object.
 		 * @param obj the tagged object.
 		 */
-		public BerTaggedObject(
-			bool			explicitly,
-			int				tagNo,
-			Asn1Encodable	obj)
-			: base(explicitly, tagNo, obj)
+        public BerTaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+			: base(isExplicit, tagNo, obj)
 		{
 		}
 
-		/**
-		 * create an implicitly tagged object that contains a zero
-		 * length sequence.
-		 */
-		public BerTaggedObject(
-			int tagNo)
-			: base(false, tagNo, BerSequence.Empty)
-		{
-		}
+        public BerTaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(isExplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal BerTaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(explicitness, tagClass, tagNo, obj)
+        {
+        }
 
         internal override string Asn1Encoding
         {
@@ -116,5 +126,10 @@ namespace Org.BouncyCastle.Asn1
         {
             return new BerSequence(asn1Object);
         }
+
+        internal override Asn1TaggedObject ReplaceTag(int tagClass, int tagNo)
+        {
+            return new BerTaggedObject(explicitness, tagClass, tagNo, obj);
+        }
     }
 }
diff --git a/crypto/src/asn1/DLApplicationSpecific.cs b/crypto/src/asn1/DLApplicationSpecific.cs
new file mode 100644
index 000000000..8fffcf65b
--- /dev/null
+++ b/crypto/src/asn1/DLApplicationSpecific.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1
+{
+    internal class DLApplicationSpecific
+        : DerApplicationSpecific
+    {
+        internal DLApplicationSpecific(int tagNo, Asn1Encodable baseEncodable)
+            : this(true, tagNo, baseEncodable)
+        {
+        }
+
+        internal DLApplicationSpecific(bool isExplicit, int tagNo, Asn1Encodable baseEncodable)
+            : base(new DLTaggedObject(isExplicit, Asn1Tags.Application, tagNo, baseEncodable))
+        {
+        }
+
+        internal DLApplicationSpecific(int tagNo, Asn1EncodableVector contentsElements)
+            : base(new DLTaggedObject(false, Asn1Tags.Application, tagNo, DLSequence.FromVector(contentsElements)))
+        {
+        }
+
+        internal DLApplicationSpecific(Asn1TaggedObject taggedObject)
+            : base(taggedObject)
+        {
+        }
+    }
+}
diff --git a/crypto/src/asn1/DLTaggedObject.cs b/crypto/src/asn1/DLTaggedObject.cs
index 1c5e990b4..314b42799 100644
--- a/crypto/src/asn1/DLTaggedObject.cs
+++ b/crypto/src/asn1/DLTaggedObject.cs
@@ -12,13 +12,23 @@ namespace Org.BouncyCastle.Asn1
         {
         }
 
-        internal DLTaggedObject(bool explicitly, int tagNo, Asn1Encodable obj)
-            : base(explicitly, tagNo, obj)
+        internal DLTaggedObject(int tagClass, int tagNo, Asn1Encodable obj)
+            : base(tagClass, tagNo, obj)
         {
         }
 
-        internal DLTaggedObject(int tagNo)
-            : base(false, tagNo, DLSequence.Empty)
+        internal DLTaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+            : base(isExplicit, tagNo, obj)
+        {
+        }
+
+        internal DLTaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(isExplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal DLTaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(explicitness, tagClass, tagNo, obj)
         {
         }
 
@@ -97,6 +107,11 @@ namespace Org.BouncyCastle.Asn1
             return new DLSequence(asn1Object);
         }
 
+        internal override Asn1TaggedObject ReplaceTag(int tagClass, int tagNo)
+        {
+            return new DLTaggedObject(explicitness, tagClass, tagNo, obj);
+        }
+
         private int GetContentsLengthDL(Asn1Object baseObject, bool withBaseID)
         {
             if (m_contentsLengthDL < 0)
diff --git a/crypto/src/asn1/DerApplicationSpecific.cs b/crypto/src/asn1/DerApplicationSpecific.cs
index bc48d24e5..39c2aec28 100644
--- a/crypto/src/asn1/DerApplicationSpecific.cs
+++ b/crypto/src/asn1/DerApplicationSpecific.cs
@@ -11,225 +11,219 @@ namespace Org.BouncyCastle.Asn1
     public class DerApplicationSpecific
         : Asn1Object
     {
-		private readonly bool	isConstructed;
-        private readonly int	tag;
-        private readonly byte[]	octets;
-
-		internal DerApplicationSpecific(
-			bool	isConstructed,
-			int		tag,
-			byte[]	octets)
-		{
-			this.isConstructed = isConstructed;
-			this.tag = tag;
-			this.octets = octets;
-		}
-
-		public DerApplicationSpecific(
-            int		tag,
-            byte[]	octets)
-			: this(false, tag, octets)
-        {
-        }
-
-		public DerApplicationSpecific(
-			int				tag, 
-			Asn1Encodable	obj) 
-			: this(true, tag, obj)
-		{
-		}
-
-		public DerApplicationSpecific(
-			bool			isExplicit,
-			int				tag,
-			Asn1Encodable	obj)
-		{
-            Asn1Object asn1Obj = obj.ToAsn1Object();
-
-            byte[] data = asn1Obj.GetDerEncoded();
-
-            this.isConstructed = Asn1TaggedObject.IsConstructed(isExplicit, asn1Obj);
-			this.tag = tag;
-
-			if (isExplicit)
-			{
-				this.octets = data;
-			}
-			else
-			{
-				int lenBytes = GetLengthOfHeader(data);
-				byte[] tmp = new byte[data.Length - lenBytes];
-				Array.Copy(data, lenBytes, tmp, 0, tmp.Length);
-				this.octets = tmp;
-			}
-		}
-
-		public DerApplicationSpecific(
-			int					tagNo,
-			Asn1EncodableVector	vec)
-		{
-			this.tag = tagNo;
-			this.isConstructed = true;
-			MemoryStream bOut = new MemoryStream();
-
-			for (int i = 0; i != vec.Count; i++)
-			{
-				try
-				{
-					byte[] bs = vec[i].GetDerEncoded();
-					bOut.Write(bs, 0, bs.Length);
-                }
-				catch (IOException e)
-				{
-					throw new InvalidOperationException("malformed object", e);
-				}
-			}
-			this.octets = bOut.ToArray();
-		}
-
-		private int GetLengthOfHeader(
-			byte[] data)
-		{
-            int length = data[1]; // TODO: assumes 1 byte tag
-
-            if (length == 0x80)
+        public static DerApplicationSpecific GetInstance(object obj)
+        {
+            if (obj == null || obj is DerApplicationSpecific)
             {
-                return 2;      // indefinite-length encoding
+                return (DerApplicationSpecific)obj;
             }
-
-            if (length > 127)
+            else if (obj is byte[])
             {
-                int size = length & 0x7f;
-
-                // Note: The invalid long form "0xff" (see X.690 8.1.3.5c) will be caught here
-                if (size > 4)
+                try
                 {
-                    throw new InvalidOperationException("DER length more than 4 bytes: " + size);
+                    return GetInstance(FromByteArray((byte[])obj));
+                }
+                catch (IOException e)
+                {
+                    throw new ArgumentException("failed to construct application-specific from byte[]: " + e.Message);
                 }
-
-                return size + 2;
             }
 
-            return 2;
+            throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj), "obj");
         }
 
-		public bool IsConstructed()
+        internal readonly Asn1TaggedObject m_taggedObject;
+
+        /**
+         * Create an application specific object from the passed in data. This will assume
+         * the data does not represent a constructed object.
+         *
+         * @param tagNo the tag number for this object.
+         * @param contentsOctets the encoding of the object's body.
+         */
+        public DerApplicationSpecific(int tagNo, byte[] contentsOctets)
+            : this(new DerTaggedObject(false, Asn1Tags.Application, tagNo, new DerOctetString(contentsOctets)))
         {
-			return isConstructed;
         }
 
-		public byte[] GetContents()
+        /**
+         * Create an application specific object with a tagging of explicit/constructed.
+         *
+         * @param tag the tag number for this object.
+         * @param object the object to be contained.
+         */
+        public DerApplicationSpecific(int tag, Asn1Encodable baseEncodable)
+            : this(true, tag, baseEncodable)
         {
-            return octets;
         }
 
-		public int ApplicationTag
+        /**
+         * Create an application specific object with the tagging style given by the value of explicit.
+         *
+         * @param explicit true if the object is explicitly tagged.
+         * @param tagNo the tag number for this object.
+         * @param baseEncodable the object to be contained.
+         */
+        public DerApplicationSpecific(bool isExplicit, int tagNo, Asn1Encodable baseEncodable)
+            : this(new DerTaggedObject(isExplicit, Asn1Tags.Application, tagNo, baseEncodable))
         {
-            get { return tag; }
         }
 
-		/**
-		 * Return the enclosed object assuming explicit tagging.
-		 *
-		 * @return  the resulting object
-		 * @throws IOException if reconstruction fails.
-		 */
-		public Asn1Object GetObject()
+        /**
+         * Create an application specific object which is marked as constructed
+         *
+         * @param tagNo the tag number for this object.
+         * @param contentsElements   the objects making up the application specific object.
+         */
+        public DerApplicationSpecific(int tagNo, Asn1EncodableVector contentsElements)
+            : this(new DerTaggedObject(false, Asn1Tags.Application, tagNo, DerSequence.FromVector(contentsElements)))
         {
-			return FromByteArray(GetContents());
-		}
+        }
 
-		/**
-		 * Return the enclosed object assuming implicit tagging.
-		 *
-		 * @param derTagNo the type tag that should be applied to the object's contents.
-		 * @return  the resulting object
-		 * @throws IOException if reconstruction fails.
-		 */
-		public Asn1Object GetObject(
-			int derTagNo)
-		{
-			if (derTagNo >= 0x1f)
-				throw new IOException("unsupported tag number");
+        internal DerApplicationSpecific(Asn1TaggedObject taggedObject)
+            //: base(taggedObject.explicitness, CheckTagClass(taggedObject.tagClass), taggedObject.tagNo,
+            //      taggedObject.obj)
+        {
+            CheckTagClass(taggedObject.TagClass);
 
-			byte[] orig = this.GetEncoded();
-			byte[] tmp = ReplaceTagNumber(derTagNo, orig);
+            this.m_taggedObject = taggedObject;
+        }
 
-			if ((orig[0] & Asn1Tags.Constructed) != 0)
-			{
-				tmp[0] |= Asn1Tags.Constructed;
-			}
+        public int ApplicationTag
+        {
+            get { return m_taggedObject.TagNo; }
+        }
 
-			return FromByteArray(tmp);
-		}
+        public byte[] GetContents()
+        {
+            return m_taggedObject.GetContents();
+        }
 
-        internal override bool EncodeConstructed(int encoding)
+        public Asn1Object GetEnclosedObject()
         {
-            return isConstructed;
+            return m_taggedObject.GetBaseObject().ToAsn1Object();
         }
 
-        internal override int EncodedLength(int encoding, bool withID)
+        [Obsolete("Use GetEnclosedObject instead")]
+        public Asn1Object GetObject()
         {
-            return Asn1OutputStream.GetLengthOfEncodingDL(withID, tag, octets.Length);
+            return GetEnclosedObject();
         }
 
-        internal override void Encode(Asn1OutputStream asn1Out, bool withID)
+        public Asn1Object GetObject(int tagNo)
+        {
+            // TODO[asn1] Implement Asn1TaggedObject.GetBaseUniversal
+            //return taggedObject.GetBaseUniversal(false, tagNo);
+
+            if (tagNo >= 0x1F)
+                throw new IOException("unsupported tag number");
+
+            byte[] orig = this.GetEncoded();
+            byte[] tmp = ReplaceTagNumber(tagNo, orig);
+
+            if ((orig[0] & Asn1Tags.Constructed) != 0)
+            {
+                tmp[0] |= Asn1Tags.Constructed;
+            }
+
+            return FromByteArray(tmp);
+        }
+
+        public bool HasApplicationTag(int tagNo)
+        {
+            return m_taggedObject.HasTag(Asn1Tags.Application, tagNo);
+        }
+
+        public bool IsConstructed()
+        {
+            return m_taggedObject.IsConstructed();
+        }
+
+        /**
+         * DerApplicationSpecific uses an internal Asn1TaggedObject for the
+         * implementation, and will soon be deprecated in favour of using
+         * Asn1TaggedObject with a tag class of {@link Asn1Tags#Application}. This method
+         * lets you get the internal Asn1TaggedObject so that client code can begin the
+         * migration.
+         */
+        public Asn1TaggedObject TaggedObject
         {
-			int flags = Asn1Tags.Application;
-			if (isConstructed)
-			{
-                flags |= Asn1Tags.Constructed; 
-			}
+            get { return m_taggedObject; }
+        }
 
-            asn1Out.WriteEncodingDL(withID, flags, tag, octets);
-		}
+        protected override bool Asn1Equals(Asn1Object asn1Object)
+        {
+            Asn1TaggedObject that;
+            if (asn1Object is DerApplicationSpecific)
+            {
+                that = ((DerApplicationSpecific)asn1Object).m_taggedObject;
+            }
+            else if (asn1Object is Asn1TaggedObject)
+            {
+                that = (Asn1TaggedObject)asn1Object;
+            }
+            else
+            {
+                return false;
+            }
+
+            return m_taggedObject.Equals(that);
+        }
 
-		protected override bool Asn1Equals(
-			Asn1Object asn1Object)
+        protected override int Asn1GetHashCode()
         {
-			DerApplicationSpecific other = asn1Object as DerApplicationSpecific;
+            return m_taggedObject.CallAsn1GetHashCode();
+        }
 
-			if (other == null)
-				return false;
+        internal override bool EncodeConstructed(int encoding)
+        {
+            return m_taggedObject.EncodeConstructed(encoding);
+        }
 
-			return this.isConstructed == other.isConstructed
-				&& this.tag == other.tag
-				&& Arrays.AreEqual(this.octets, other.octets);
+        internal override int EncodedLength(int encoding, bool withID)
+        {
+            return m_taggedObject.EncodedLength(encoding, withID);
         }
 
-		protected override int Asn1GetHashCode()
-		{
-			return isConstructed.GetHashCode() ^ tag.GetHashCode() ^ Arrays.GetHashCode(octets);
+        internal override void Encode(Asn1OutputStream asn1Out, bool withID)
+        {
+            m_taggedObject.Encode(asn1Out, withID);
         }
 
-		private byte[] ReplaceTagNumber(
-			int		newTag,
-			byte[]	input)
-		{
-			int tagNo = input[0] & 0x1f;
-			int index = 1;
+        private byte[] ReplaceTagNumber(int newTag, byte[] input)
+        {
+            int tagNo = input[0] & 0x1f;
+            int index = 1;
 
             // with tagged object tag number is bottom 5 bits, or stored at the start of the content
-			if (tagNo == 0x1f)
-			{
-				int b = input[index++];
+            if (tagNo == 0x1f)
+            {
+                int b = input[index++];
 
                 // X.690-0207 8.1.2.4.2
-				// "c) bits 7 to 1 of the first subsequent octet shall not all be zero."
-				if ((b & 0x7f) == 0) // Note: -1 will pass
-					throw new IOException("corrupted stream - invalid high tag number found");
+                // "c) bits 7 to 1 of the first subsequent octet shall not all be zero."
+                if ((b & 0x7f) == 0) // Note: -1 will pass
+                    throw new IOException("corrupted stream - invalid high tag number found");
 
                 while ((b & 0x80) != 0)
-				{
-					b = input[index++];
-				}
-			}
+                {
+                    b = input[index++];
+                }
+            }
 
             int remaining = input.Length - index;
             byte[] tmp = new byte[1 + remaining];
             tmp[0] = (byte)newTag;
-			Array.Copy(input, index, tmp, 1, remaining);
-			return tmp;
-		}
+            Array.Copy(input, index, tmp, 1, remaining);
+            return tmp;
+        }
+
+        private static int CheckTagClass(int tagClass)
+        {
+            if (Asn1Tags.Application != tagClass)
+                throw new ArgumentException();
+
+            return tagClass;
+        }
     }
 }
diff --git a/crypto/src/asn1/DerTaggedObject.cs b/crypto/src/asn1/DerTaggedObject.cs
index e58590c8d..66f804ebb 100644
--- a/crypto/src/asn1/DerTaggedObject.cs
+++ b/crypto/src/asn1/DerTaggedObject.cs
@@ -13,38 +13,44 @@ namespace Org.BouncyCastle.Asn1
         private int m_contentsLengthDer = -1;
 
         /**
-		 * @param tagNo the tag number for this object.
-		 * @param obj the tagged object.
+		 * create an implicitly tagged object that contains a zero
+		 * length sequence.
 		 */
-        public DerTaggedObject(
-			int				tagNo,
-			Asn1Encodable	obj)
-			: base(tagNo, obj)
+        [Obsolete("Will be removed")]
+        public DerTaggedObject(int tagNo)
+            : base(false, tagNo, DerSequence.Empty)
+        {
+        }
+
+        public DerTaggedObject(int tagNo, Asn1Encodable obj)
+			: base(true, tagNo, obj)
 		{
 		}
 
-		/**
-		 * @param explicitly true if an explicitly tagged object.
+        public DerTaggedObject(int tagClass, int tagNo, Asn1Encodable obj)
+            : base(true, tagClass, tagNo, obj)
+        {
+        }
+
+        /**
+		 * @param isExplicit true if an explicitly tagged object.
 		 * @param tagNo the tag number for this object.
 		 * @param obj the tagged object.
 		 */
-		public DerTaggedObject(
-			bool			explicitly,
-			int				tagNo,
-			Asn1Encodable	obj)
-			: base(explicitly, tagNo, obj)
+        public DerTaggedObject(bool isExplicit, int tagNo, Asn1Encodable obj)
+			: base(isExplicit, tagNo, obj)
 		{
 		}
 
-		/**
-		 * create an implicitly tagged object that contains a zero
-		 * length sequence.
-		 */
-		public DerTaggedObject(
-			int tagNo)
-			: base(false, tagNo, DerSequence.Empty)
-		{
-		}
+        public DerTaggedObject(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(isExplicit, tagClass, tagNo, obj)
+        {
+        }
+
+        internal DerTaggedObject(int explicitness, int tagClass, int tagNo, Asn1Encodable obj)
+            : base(explicitness, tagClass, tagNo, obj)
+        {
+        }
 
         internal override string Asn1Encoding
         {
@@ -108,6 +114,11 @@ namespace Org.BouncyCastle.Asn1
             return new DerSequence(asn1Object);
         }
 
+        internal override Asn1TaggedObject ReplaceTag(int tagClass, int tagNo)
+        {
+            return new DerTaggedObject(explicitness, tagClass, tagNo, obj);
+        }
+
         private int GetContentsLengthDer(Asn1Object baseObject, bool withBaseID)
         {
             if (m_contentsLengthDer < 0)
diff --git a/crypto/src/asn1/util/Asn1Dump.cs b/crypto/src/asn1/util/Asn1Dump.cs
index 0d3382d00..f573d3663 100644
--- a/crypto/src/asn1/util/Asn1Dump.cs
+++ b/crypto/src/asn1/util/Asn1Dump.cs
@@ -23,11 +23,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
          *
          * @param obj the Asn1Object to be dumped out.
          */
-        private static void AsString(
-            string			indent,
-            bool			verbose,
-            Asn1Object		obj,
-            StringBuilder	buf)
+        private static void AsString(string indent, bool verbose, Asn1Object obj, StringBuilder buf)
         {
             if (obj is Asn1Null)
             {
@@ -42,7 +38,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
                 {
                     buf.Append("BER Sequence");
                 }
-                else if (obj is DerSequence)
+                else if (!(obj is DLSequence))
                 {
                     buf.Append("DER Sequence");
                 }
@@ -67,7 +63,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
                 {
                     buf.Append("BER Set");
                 }
-                else if (obj is DerSet)
+                else if (!(obj is DLSet))
                 {
                     buf.Append("DER Set");
                 }
@@ -85,23 +81,29 @@ namespace Org.BouncyCastle.Asn1.Utilities
                     AsString(elementsIndent, verbose, set[i].ToAsn1Object(), buf);
                 }
             }
+            else if (obj is DerApplicationSpecific)
+            {
+                AsString(indent, verbose, ((DerApplicationSpecific)obj).TaggedObject, buf);
+            }
             else if (obj is Asn1TaggedObject)
             {
-                string tab = indent + Tab;
                 buf.Append(indent);
                 if (obj is BerTaggedObject)
                 {
-                    buf.Append("BER Tagged [");
+                    buf.Append("BER Tagged ");
+                }
+                else if (!(obj is DLTaggedObject))
+                {
+                    buf.Append("DER Tagged ");
                 }
                 else
                 {
-                    buf.Append("Tagged [");
+                    buf.Append("Tagged ");
                 }
 
                 Asn1TaggedObject o = (Asn1TaggedObject)obj;
 
-                buf.Append(o.TagNo.ToString());
-                buf.Append(']');
+                buf.Append(Asn1Utilities.GetTagText(o));
 
                 if (!o.IsExplicit())
                 {
@@ -110,7 +112,9 @@ namespace Org.BouncyCastle.Asn1.Utilities
 
                 buf.Append(NewLine);
 
-                AsString(tab, verbose, o.GetObject(), buf);
+                string baseIndent = indent + Tab;
+
+                AsString(baseIndent, verbose, o.GetBaseObject().ToAsn1Object(), buf);
             }
             else if (obj is DerObjectIdentifier)
             {
@@ -131,20 +135,20 @@ namespace Org.BouncyCastle.Asn1.Utilities
             else if (obj is BerOctetString)
             {
                 byte[] octets = ((Asn1OctetString)obj).GetOctets();
-                string extra = verbose ? dumpBinaryDataAsString(indent, octets) : "";
+                string extra = verbose ? DumpBinaryDataAsString(indent, octets) : "";
                 buf.Append(indent + "BER Octet String" + "[" + octets.Length + "] " + extra + NewLine);
             }
             else if (obj is DerOctetString)
             {
                 byte[] octets = ((Asn1OctetString)obj).GetOctets();
-                string extra = verbose ? dumpBinaryDataAsString(indent, octets) : "";
+                string extra = verbose ? DumpBinaryDataAsString(indent, octets) : "";
                 buf.Append(indent + "DER Octet String" + "[" + octets.Length + "] " + extra + NewLine);
             }
             else if (obj is DerBitString)
             {
                 DerBitString bt = (DerBitString)obj; 
                 byte[] bytes = bt.GetBytes();
-                string extra = verbose ? dumpBinaryDataAsString(indent, bytes) : "";
+                string extra = verbose ? DumpBinaryDataAsString(indent, bytes) : "";
                 buf.Append(indent + "DER Bit String" + "[" + bytes.Length + ", " + bt.PadBits + "] " + extra + NewLine);
             }
             else if (obj is DerIA5String)
@@ -187,14 +191,6 @@ namespace Org.BouncyCastle.Asn1.Utilities
             {
                 buf.Append(indent + "GeneralizedTime(" + ((DerGeneralizedTime)obj).GetTime() + ") " + NewLine);
             }
-            else if (obj is BerApplicationSpecific)
-            {
-                buf.Append(outputApplicationSpecific("BER", indent, verbose, (BerApplicationSpecific)obj));
-            }
-            else if (obj is DerApplicationSpecific)
-            {
-                buf.Append(outputApplicationSpecific("DER", indent, verbose, (DerApplicationSpecific)obj));
-            }
             else if (obj is DerEnumerated)
             {
                 DerEnumerated en = (DerEnumerated)obj;
@@ -227,44 +223,13 @@ namespace Org.BouncyCastle.Asn1.Utilities
             }
         }
 
-        private static string outputApplicationSpecific(
-            string					type,
-            string					indent,
-            bool					verbose,
-            DerApplicationSpecific	app)
-        {
-            StringBuilder buf = new StringBuilder();
-
-            if (app.IsConstructed())
-            {
-                try
-                {
-                    Asn1Sequence s = Asn1Sequence.GetInstance(app.GetObject(Asn1Tags.Sequence));
-                    buf.Append(indent + type + " ApplicationSpecific[" + app.ApplicationTag + "]" + NewLine);
-                    foreach (Asn1Encodable ae in s)
-                    {
-                        AsString(indent + Tab, verbose, ae.ToAsn1Object(), buf);
-                    }
-                }
-                catch (IOException e)
-                {
-                    buf.Append(e);
-                }
-                return buf.ToString();
-            }
-
-            return indent + type + " ApplicationSpecific[" + app.ApplicationTag + "] ("
-                + Hex.ToHexString(app.GetContents()) + ")" + NewLine;
-        }
-
         /**
          * dump out a DER object as a formatted string, in non-verbose mode
          *
          * @param obj the Asn1Encodable to be dumped out.
          * @return  the resulting string.
          */
-        public static string DumpAsString(
-            Asn1Encodable obj)
+        public static string DumpAsString(Asn1Encodable obj)
         {
             return DumpAsString(obj, false);
         }
@@ -276,16 +241,14 @@ namespace Org.BouncyCastle.Asn1.Utilities
          * @param verbose  if true, dump out the contents of octet and bit strings.
          * @return  the resulting string.
          */
-        public static string DumpAsString(
-            Asn1Encodable	obj,
-            bool			verbose)
+        public static string DumpAsString(Asn1Encodable obj, bool verbose)
         {
             StringBuilder buf = new StringBuilder();
             AsString("", verbose, obj.ToAsn1Object(), buf);
             return buf.ToString();
         }
 
-        private static string dumpBinaryDataAsString(string indent, byte[] bytes)
+        private static string DumpBinaryDataAsString(string indent, byte[] bytes)
         {
             indent += Tab;
 
@@ -298,7 +261,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
                     buf.Append(indent);
                     buf.Append(Hex.ToHexString(bytes, i, SampleSize));
                     buf.Append(Tab);
-                    buf.Append(calculateAscString(bytes, i, SampleSize));
+                    buf.Append(CalculateAscString(bytes, i, SampleSize));
                     buf.Append(NewLine);
                 }
                 else
@@ -310,7 +273,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
                         buf.Append("  ");
                     }
                     buf.Append(Tab);
-                    buf.Append(calculateAscString(bytes, i, bytes.Length - i));
+                    buf.Append(CalculateAscString(bytes, i, bytes.Length - i));
                     buf.Append(NewLine);
                 }
             }
@@ -318,10 +281,7 @@ namespace Org.BouncyCastle.Asn1.Utilities
             return buf.ToString();
         }
 
-        private static string calculateAscString(
-            byte[]	bytes,
-            int		off,
-            int		len)
+        private static string CalculateAscString(byte[] bytes, int off, int len)
         {
             StringBuilder buf = new StringBuilder();