diff --git a/crypto/BouncyCastle.Android.csproj b/crypto/BouncyCastle.Android.csproj
index cdc4843bd..198ec093e 100644
--- a/crypto/BouncyCastle.Android.csproj
+++ b/crypto/BouncyCastle.Android.csproj
@@ -144,6 +144,7 @@
<Compile Include="src\asn1\DLSequence.cs" />
<Compile Include="src\asn1\DLSet.cs" />
<Compile Include="src\asn1\DLTaggedObject.cs" />
+ <Compile Include="src\asn1\DLTaggedObjectParser.cs" />
<Compile Include="src\asn1\IAsn1ApplicationSpecificParser.cs" />
<Compile Include="src\asn1\IAsn1Choice.cs" />
<Compile Include="src\asn1\IAsn1Convertible.cs" />
diff --git a/crypto/BouncyCastle.csproj b/crypto/BouncyCastle.csproj
index bbcfd9324..849dd3202 100644
--- a/crypto/BouncyCastle.csproj
+++ b/crypto/BouncyCastle.csproj
@@ -138,6 +138,7 @@
<Compile Include="src\asn1\DLSequence.cs" />
<Compile Include="src\asn1\DLSet.cs" />
<Compile Include="src\asn1\DLTaggedObject.cs" />
+ <Compile Include="src\asn1\DLTaggedObjectParser.cs" />
<Compile Include="src\asn1\IAsn1ApplicationSpecificParser.cs" />
<Compile Include="src\asn1\IAsn1Choice.cs" />
<Compile Include="src\asn1\IAsn1Convertible.cs" />
diff --git a/crypto/BouncyCastle.iOS.csproj b/crypto/BouncyCastle.iOS.csproj
index 415992207..456a15b19 100644
--- a/crypto/BouncyCastle.iOS.csproj
+++ b/crypto/BouncyCastle.iOS.csproj
@@ -139,6 +139,7 @@
<Compile Include="src\asn1\DLSequence.cs" />
<Compile Include="src\asn1\DLSet.cs" />
<Compile Include="src\asn1\DLTaggedObject.cs" />
+ <Compile Include="src\asn1\DLTaggedObjectParser.cs" />
<Compile Include="src\asn1\IAsn1ApplicationSpecificParser.cs" />
<Compile Include="src\asn1\IAsn1Choice.cs" />
<Compile Include="src\asn1\IAsn1Convertible.cs" />
diff --git a/crypto/crypto.csproj b/crypto/crypto.csproj
index 72fcfe5b9..a588a961a 100644
--- a/crypto/crypto.csproj
+++ b/crypto/crypto.csproj
@@ -579,6 +579,11 @@
BuildAction = "Compile"
/>
<File
+ RelPath = "src\asn1\DLTaggedObjectParser.cs"
+ SubType = "Code"
+ BuildAction = "Compile"
+ />
+ <File
RelPath = "src\asn1\IAsn1ApplicationSpecificParser.cs"
SubType = "Code"
BuildAction = "Compile"
diff --git a/crypto/src/asn1/ASN1StreamParser.cs b/crypto/src/asn1/ASN1StreamParser.cs
index 51af50728..6128c9b78 100644
--- a/crypto/src/asn1/ASN1StreamParser.cs
+++ b/crypto/src/asn1/ASN1StreamParser.cs
@@ -35,105 +35,36 @@ namespace Org.BouncyCastle.Asn1
this.tmpBuffers = tmpBuffers;
}
- internal IAsn1Convertible ReadIndef(int tagNo)
- {
- // Note: INDEF => CONSTRUCTED
-
- // TODO There are other tags that may be constructed (e.g. BIT_STRING)
- switch (tagNo)
- {
- case Asn1Tags.External:
- return new DerExternalParser(this);
- case Asn1Tags.OctetString:
- return new BerOctetStringParser(this);
- case Asn1Tags.Sequence:
- return new BerSequenceParser(this);
- case Asn1Tags.Set:
- return new BerSetParser(this);
- default:
- throw new Asn1Exception("unknown BER object encountered: 0x" + tagNo.ToString("X"));
- }
- }
-
- internal IAsn1Convertible ReadImplicit(bool constructed, int tagNo)
- {
- if (_in is IndefiniteLengthInputStream)
- {
- if (!constructed)
- throw new IOException("indefinite-length primitive encoding encountered");
-
- return ReadIndef(tagNo);
- }
-
- if (constructed)
- {
- switch (tagNo)
- {
- case Asn1Tags.Set:
- return new DerSetParser(this);
- case Asn1Tags.Sequence:
- return new DerSequenceParser(this);
- case Asn1Tags.OctetString:
- return new BerOctetStringParser(this);
- }
- }
- else
- {
- switch (tagNo)
- {
- case Asn1Tags.Set:
- throw new Asn1Exception("sequences must use constructed encoding (see X.690 8.9.1/8.10.1)");
- case Asn1Tags.Sequence:
- throw new Asn1Exception("sets must use constructed encoding (see X.690 8.11.1/8.12.1)");
- case Asn1Tags.OctetString:
- return new DerOctetStringParser((DefiniteLengthInputStream)_in);
- }
- }
-
- throw new Asn1Exception("implicit tagging not implemented");
- }
-
- internal Asn1Object ReadTaggedObject(int tagClass, int tagNo, bool constructed)
- {
- if (!constructed)
- {
- // Note: !CONSTRUCTED => IMPLICIT
- byte[] contentsOctets = ((DefiniteLengthInputStream)_in).ToArray();
- return Asn1TaggedObject.CreatePrimitive(tagClass, tagNo, contentsOctets);
- }
-
- bool isIL = (_in is IndefiniteLengthInputStream);
- Asn1EncodableVector contentsElements = ReadVector();
- return Asn1TaggedObject.CreateConstructed(tagClass, tagNo, isIL, contentsElements);
- }
-
public virtual IAsn1Convertible ReadObject()
{
int tagHdr = _in.ReadByte();
- if (tagHdr == -1)
+ if (tagHdr < 0)
return null;
- // turn off looking for "00" while we resolve the tag
- Set00Check(false);
+ return ImplParseObject(tagHdr);
+ }
+
+ internal IAsn1Convertible ImplParseObject(int tagHdr)
+ {
+ // turn off looking for "00" while we resolve the tag
+ Set00Check(false);
//
// calculate tag number
//
int tagNo = Asn1InputStream.ReadTagNumber(_in, tagHdr);
- bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
-
//
// calculate length
//
int length = Asn1InputStream.ReadLength(_in, _limit,
- tagNo == Asn1Tags.OctetString || tagNo == Asn1Tags.Sequence || tagNo == Asn1Tags.Set ||
- tagNo == Asn1Tags.External);
+ tagNo == Asn1Tags.BitString || tagNo == Asn1Tags.OctetString || tagNo == Asn1Tags.Sequence ||
+ tagNo == Asn1Tags.Set || tagNo == Asn1Tags.External);
if (length < 0) // indefinite-length method
{
- if (!isConstructed)
- throw new IOException("indefinite-length primitive encoding encountered");
+ if (0 == (tagHdr & Asn1Tags.Constructed))
+ throw new IOException("indefinite-length primitive encoding encountered");
IndefiniteLengthInputStream indIn = new IndefiniteLengthInputStream(_in, _limit);
Asn1StreamParser sp = new Asn1StreamParser(indIn, _limit, tmpBuffers);
@@ -144,86 +75,184 @@ namespace Org.BouncyCastle.Asn1
if (Asn1Tags.Application == tagClass)
return new BerApplicationSpecificParser(tagNo, sp);
- return new BerTaggedObjectParser(tagClass, tagNo, true, sp);
+ return new BerTaggedObjectParser(tagClass, tagNo, sp);
}
- return sp.ReadIndef(tagNo);
+ return sp.ParseImplicitConstructedIL(tagNo);
}
else
{
DefiniteLengthInputStream defIn = new DefiniteLengthInputStream(_in, length, _limit);
+ if (0 == (tagHdr & Asn1Tags.Flags))
+ return ParseImplicitPrimitive(tagNo, defIn);
+
+ Asn1StreamParser sp = new Asn1StreamParser(defIn, defIn.Remaining, tmpBuffers);
+
int tagClass = tagHdr & Asn1Tags.Private;
if (0 != tagClass)
{
- Asn1StreamParser sub = new Asn1StreamParser(defIn, defIn.Remaining, tmpBuffers);
+ bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
+ // TODO[asn1] Special handling can be removed once ASN1ApplicationSpecific types removed.
if (Asn1Tags.Application == tagClass)
- return (DLApplicationSpecific)sub.ReadTaggedObject(tagClass, tagNo, isConstructed);
-
- return new BerTaggedObjectParser(tagClass, tagNo, isConstructed, sub);
- }
-
- if (!isConstructed)
- {
- // Some primitive encodings can be handled by parsers too...
- switch (tagNo)
{
- case Asn1Tags.OctetString:
- return new DerOctetStringParser(defIn);
+ // This cast is ensuring the current user-expected return type.
+ return (DLApplicationSpecific)sp.LoadTaggedDL(tagClass, tagNo, isConstructed);
}
- try
- {
- return Asn1InputStream.CreatePrimitiveDerObject(tagNo, defIn, tmpBuffers);
- }
- catch (ArgumentException e)
- {
- throw new Asn1Exception("corrupted stream detected", e);
- }
+ return new DLTaggedObjectParser(tagClass, tagNo, isConstructed, sp);
}
- Asn1StreamParser sp = new Asn1StreamParser(defIn, defIn.Remaining, tmpBuffers);
-
- // TODO There are other tags that may be constructed (e.g. BitString)
- switch (tagNo)
- {
- case Asn1Tags.OctetString:
- return new BerOctetStringParser(sp);
- case Asn1Tags.Sequence:
- return new DerSequenceParser(sp);
- case Asn1Tags.Set:
- return new DerSetParser(sp);
- case Asn1Tags.External:
- return new DerExternalParser(sp);
- default:
- throw new IOException("unknown tag " + tagNo + " encountered");
- }
+ return sp.ParseImplicitConstructedDL(tagNo);
}
}
- private void Set00Check(
- bool enabled)
- {
- if (_in is IndefiniteLengthInputStream)
- {
- ((IndefiniteLengthInputStream) _in).SetEofOn00(enabled);
- }
- }
+ internal Asn1Object LoadTaggedDL(int tagClass, int tagNo, bool constructed)
+ {
+ if (!constructed)
+ {
+ byte[] contentsOctets = ((DefiniteLengthInputStream)_in).ToArray();
+ return Asn1TaggedObject.CreatePrimitive(tagClass, tagNo, contentsOctets);
+ }
+
+ Asn1EncodableVector contentsElements = ReadVector();
+ return Asn1TaggedObject.CreateConstructedDL(tagClass, tagNo, contentsElements);
+ }
+
+ internal Asn1Object LoadTaggedIL(int tagClass, int tagNo)
+ {
+ Asn1EncodableVector contentsElements = ReadVector();
+ return Asn1TaggedObject.CreateConstructedIL(tagClass, tagNo, contentsElements);
+ }
+
+ internal IAsn1Convertible ParseImplicitConstructedDL(int univTagNo)
+ {
+ switch (univTagNo)
+ {
+ // TODO[asn1] DLConstructedBitStringParser
+ //case Asn1Tags.BitString:
+ // return new BerBitStringParser(this);
+ case Asn1Tags.External:
+ return new DerExternalParser(this);
+ case Asn1Tags.OctetString:
+ // TODO[asn1] DLConstructedOctetStringParser
+ return new BerOctetStringParser(this);
+ case Asn1Tags.Set:
+ return new DerSetParser(this);
+ case Asn1Tags.Sequence:
+ return new DerSequenceParser(this);
+ default:
+ throw new Asn1Exception("unknown DL object encountered: 0x" + univTagNo.ToString("X"));
+ }
+ }
+
+ internal IAsn1Convertible ParseImplicitConstructedIL(int univTagNo)
+ {
+ switch (univTagNo)
+ {
+ // TODO[asn1] BerBitStringParser
+ //case Asn1Tags.BitString:
+ // return new BerBitStringParser(this);
+ case Asn1Tags.External:
+ // TODO[asn1] BERExternalParser
+ return new DerExternalParser(this);
+ case Asn1Tags.OctetString:
+ return new BerOctetStringParser(this);
+ case Asn1Tags.Sequence:
+ return new BerSequenceParser(this);
+ case Asn1Tags.Set:
+ return new BerSetParser(this);
+ default:
+ throw new Asn1Exception("unknown BER object encountered: 0x" + univTagNo.ToString("X"));
+ }
+ }
+
+ internal IAsn1Convertible ParseImplicitPrimitive(int univTagNo)
+ {
+ return ParseImplicitPrimitive(univTagNo, (DefiniteLengthInputStream)_in);
+ }
+ internal IAsn1Convertible ParseImplicitPrimitive(int univTagNo, DefiniteLengthInputStream defIn)
+ {
+ // Some primitive encodings can be handled by parsers too...
+ switch (univTagNo)
+ {
+ // TODO[asn1] DLBitStringParser
+ //case Asn1Tags.BitString:
+ // return new DLBitStringParser(defIn);
+ case Asn1Tags.External:
+ throw new Asn1Exception("externals must use constructed encoding (see X.690 8.18)");
+ case Asn1Tags.OctetString:
+ return new DerOctetStringParser(defIn);
+ case Asn1Tags.Set:
+ throw new Asn1Exception("sequences must use constructed encoding (see X.690 8.9.1/8.10.1)");
+ case Asn1Tags.Sequence:
+ throw new Asn1Exception("sets must use constructed encoding (see X.690 8.11.1/8.12.1)");
+ }
+
+ try
+ {
+ return Asn1InputStream.CreatePrimitiveDerObject(univTagNo, defIn, tmpBuffers);
+ }
+ catch (ArgumentException e)
+ {
+ throw new Asn1Exception("corrupted stream detected", e);
+ }
+ }
+
+ internal IAsn1Convertible ParseObject(int univTagNo)
+ {
+ if (univTagNo < 0 || univTagNo > 30)
+ throw new ArgumentException("invalid universal tag number: " + univTagNo, "univTagNo");
+
+ int tagHdr = _in.ReadByte();
+ if (tagHdr < 0)
+ return null;
+
+ if ((tagHdr & ~Asn1Tags.Constructed) != univTagNo)
+ throw new IOException("unexpected identifier encountered: " + tagHdr);
+
+ return ImplParseObject(tagHdr);
+ }
+
+ internal Asn1TaggedObjectParser ParseTaggedObject()
+ {
+ int tagHdr = _in.ReadByte();
+ if (tagHdr< 0)
+ return null;
+
+ int tagClass = tagHdr & Asn1Tags.Private;
+ if (0 == tagClass)
+ throw new Asn1Exception("no tagged object found");
+
+ return (Asn1TaggedObjectParser)ImplParseObject(tagHdr);
+ }
+
+ // TODO[asn1] Prefer 'LoadVector'
internal Asn1EncodableVector ReadVector()
{
- IAsn1Convertible obj = ReadObject();
- if (null == obj)
+ int tagHdr = _in.ReadByte();
+ if (tagHdr < 0)
return new Asn1EncodableVector(0);
Asn1EncodableVector v = new Asn1EncodableVector();
do
{
+ IAsn1Convertible obj = ImplParseObject(tagHdr);
+
v.Add(obj.ToAsn1Object());
}
- while ((obj = ReadObject()) != null);
+ while ((tagHdr = _in.ReadByte()) >= 0);
return v;
}
+
+ private void Set00Check(bool enabled)
+ {
+ if (_in is IndefiniteLengthInputStream)
+ {
+ ((IndefiniteLengthInputStream)_in).SetEofOn00(enabled);
+ }
+ }
}
}
diff --git a/crypto/src/asn1/ASN1TaggedObjectParser.cs b/crypto/src/asn1/ASN1TaggedObjectParser.cs
index d125ddc1a..68b83f290 100644
--- a/crypto/src/asn1/ASN1TaggedObjectParser.cs
+++ b/crypto/src/asn1/ASN1TaggedObjectParser.cs
@@ -21,6 +21,15 @@ namespace Org.BouncyCastle.Asn1
/// <exception cref="IOException"/>
IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo);
+ /// <summary>Needed for open types, until we have better type-guided parsing support.</summary>
+ /// <remarks>
+ /// Use sparingly for other purposes, and prefer <see cref="ParseExplicitBaseTagged"/> or
+ /// <see cref="ParseBaseUniversal(bool, int)"/> where possible. Before using, check for matching tag
+ /// <see cref="TagClass">class</see> and <see cref="TagNo">number</see>.
+ /// </remarks>
+ /// <exception cref="IOException"/>
+ IAsn1Convertible ParseExplicitBaseObject();
+
/// <exception cref="IOException"/>
Asn1TaggedObjectParser ParseExplicitBaseTagged();
diff --git a/crypto/src/asn1/Asn1InputStream.cs b/crypto/src/asn1/Asn1InputStream.cs
index d03c7a6b5..8ddfc022b 100644
--- a/crypto/src/asn1/Asn1InputStream.cs
+++ b/crypto/src/asn1/Asn1InputStream.cs
@@ -75,16 +75,19 @@ namespace Org.BouncyCastle.Asn1
*/
private Asn1Object BuildObject(int tagHdr, int tagNo, int length)
{
- bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
+ // TODO[asn1] Special-case zero length first?
DefiniteLengthInputStream defIn = new DefiniteLengthInputStream(this, length, limit);
+ if (0 == (tagHdr & Asn1Tags.Flags))
+ return CreatePrimitiveDerObject(tagNo, defIn, tmpBuffers);
+
int tagClass = tagHdr & Asn1Tags.Private;
if (0 != tagClass)
- return ReadTaggedObject(tagClass, tagNo, isConstructed, defIn);
-
- if (!isConstructed)
- return CreatePrimitiveDerObject(tagNo, defIn, tmpBuffers);
+ {
+ bool isConstructed = (tagHdr & Asn1Tags.Constructed) != 0;
+ return ReadTaggedObjectDL(tagClass, tagNo, isConstructed, defIn);
+ }
switch (tagNo)
{
@@ -103,7 +106,7 @@ namespace Org.BouncyCastle.Asn1
}
}
- internal Asn1Object ReadTaggedObject(int tagClass, int tagNo, bool constructed, DefiniteLengthInputStream defIn)
+ internal Asn1Object ReadTaggedObjectDL(int tagClass, int tagNo, bool constructed, DefiniteLengthInputStream defIn)
{
if (!constructed)
{
@@ -111,9 +114,8 @@ namespace Org.BouncyCastle.Asn1
return Asn1TaggedObject.CreatePrimitive(tagClass, tagNo, contentsOctets);
}
- bool isIL = false;
Asn1EncodableVector contentsElements = ReadVector(defIn);
- return Asn1TaggedObject.CreateConstructed(tagClass, tagNo, isIL, contentsElements);
+ return Asn1TaggedObject.CreateConstructedDL(tagClass, tagNo, contentsElements);
}
internal virtual Asn1EncodableVector ReadVector()
@@ -187,11 +189,13 @@ namespace Org.BouncyCastle.Asn1
int tagClass = tagHdr & Asn1Tags.Private;
if (0 != tagClass)
- return sp.ReadTaggedObject(tagClass, tagNo, true);
+ return sp.LoadTaggedIL(tagClass, tagNo);
- // TODO There are other tags that may be constructed (e.g. BitString)
switch (tagNo)
{
+ // TODO[asn1] BerBitStringParser
+ //case Asn1Tags.BitString:
+ // return BerBitStringParser.Parse(sp);
case Asn1Tags.OctetString:
return BerOctetStringParser.Parse(sp);
case Asn1Tags.Sequence:
@@ -199,6 +203,7 @@ namespace Org.BouncyCastle.Asn1
case Asn1Tags.Set:
return BerSetParser.Parse(sp);
case Asn1Tags.External:
+ // TODO[asn1] BerExternalParser
return DerExternalParser.Parse(sp);
default:
throw new IOException("unknown BER object encountered");
diff --git a/crypto/src/asn1/Asn1TaggedObject.cs b/crypto/src/asn1/Asn1TaggedObject.cs
index c7c0db6fc..ce5e9e3f2 100644
--- a/crypto/src/asn1/Asn1TaggedObject.cs
+++ b/crypto/src/asn1/Asn1TaggedObject.cs
@@ -396,6 +396,11 @@ namespace Org.BouncyCastle.Asn1
return asn1Object;
}
+ public IAsn1Convertible ParseExplicitBaseObject()
+ {
+ return GetExplicitBaseObject();
+ }
+
public Asn1TaggedObjectParser ParseExplicitBaseTagged()
{
return GetExplicitBaseTagged();
@@ -417,38 +422,37 @@ namespace Org.BouncyCastle.Asn1
internal abstract Asn1TaggedObject ReplaceTag(int tagClass, int tagNo);
- internal static Asn1Object CreateConstructed(int tagClass, int tagNo, bool isIL,
- Asn1EncodableVector contentsElements)
+ internal static Asn1Object CreateConstructedDL(int tagClass, int tagNo, Asn1EncodableVector contentsElements)
{
bool maybeExplicit = (contentsElements.Count == 1);
- if (isIL)
- {
- Asn1TaggedObject taggedObject = maybeExplicit
- ? new BerTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
- : new BerTaggedObject(ParsedImplicit, tagClass, tagNo, BerSequence.FromVector(contentsElements));
+ Asn1TaggedObject taggedObject = maybeExplicit
+ ? new DLTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+ : new DLTaggedObject(ParsedImplicit, tagClass, tagNo, DLSequence.FromVector(contentsElements));
- switch (tagClass)
- {
- case Asn1Tags.Application:
- return new BerApplicationSpecific(taggedObject);
- default:
- return taggedObject;
- }
- }
- else
+ switch (tagClass)
{
- Asn1TaggedObject taggedObject = maybeExplicit
- ? new DLTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
- : new DLTaggedObject(ParsedImplicit, tagClass, tagNo, DLSequence.FromVector(contentsElements));
+ case Asn1Tags.Application:
+ return new DLApplicationSpecific(taggedObject);
+ default:
+ return taggedObject;
+ }
+ }
- switch (tagClass)
- {
- case Asn1Tags.Application:
- return new DLApplicationSpecific(taggedObject);
- default:
- return taggedObject;
- }
+ internal static Asn1Object CreateConstructedIL(int tagClass, int tagNo, Asn1EncodableVector contentsElements)
+ {
+ bool maybeExplicit = (contentsElements.Count == 1);
+
+ Asn1TaggedObject taggedObject = maybeExplicit
+ ? new BerTaggedObject(ParsedExplicit, tagClass, tagNo, contentsElements[0])
+ : new BerTaggedObject(ParsedImplicit, tagClass, tagNo, BerSequence.FromVector(contentsElements));
+
+ switch (tagClass)
+ {
+ case Asn1Tags.Application:
+ return new BerApplicationSpecific(taggedObject);
+ default:
+ return taggedObject;
}
}
diff --git a/crypto/src/asn1/Asn1Tags.cs b/crypto/src/asn1/Asn1Tags.cs
index 692acdf50..670fb7d96 100644
--- a/crypto/src/asn1/Asn1Tags.cs
+++ b/crypto/src/asn1/Asn1Tags.cs
@@ -45,5 +45,7 @@ namespace Org.BouncyCastle.Asn1
public const int Tagged = 0x80;
public const int ContextSpecific = 0x80;
public const int Private = 0xC0;
+
+ public const int Flags = 0xE0;
}
}
diff --git a/crypto/src/asn1/Asn1Utilities.cs b/crypto/src/asn1/Asn1Utilities.cs
index 8a6d931c0..5605d4c54 100644
--- a/crypto/src/asn1/Asn1Utilities.cs
+++ b/crypto/src/asn1/Asn1Utilities.cs
@@ -289,5 +289,41 @@ namespace Org.BouncyCastle.Asn1
return TryParseBaseUniversal(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo, declaredExplicit,
baseTagNo);
}
+
+
+ /*
+ * Wrappers for Asn1TaggedObjectParser.ParseExplicitBaseObject
+ */
+
+ /// <exception cref="IOException"/>
+ public static IAsn1Convertible ParseExplicitBaseObject(Asn1TaggedObjectParser taggedObjectParser, int tagClass,
+ int tagNo)
+ {
+ return CheckTag(taggedObjectParser, tagClass, tagNo).ParseExplicitBaseObject();
+ }
+
+ /// <exception cref="IOException"/>
+ public static IAsn1Convertible ParseExplicitContextBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+ int tagNo)
+ {
+ return ParseExplicitBaseObject(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+ }
+
+ /// <exception cref="IOException"/>
+ public static IAsn1Convertible TryParseExplicitBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+ int tagClass, int tagNo)
+ {
+ if (!taggedObjectParser.HasTag(tagClass, tagNo))
+ return null;
+
+ return taggedObjectParser.ParseExplicitBaseObject();
+ }
+
+ /// <exception cref="IOException"/>
+ public static IAsn1Convertible TryParseExplicitContextBaseObject(Asn1TaggedObjectParser taggedObjectParser,
+ int tagNo)
+ {
+ return TryParseExplicitBaseObject(taggedObjectParser, Asn1Tags.ContextSpecific, tagNo);
+ }
}
}
diff --git a/crypto/src/asn1/BERTaggedObjectParser.cs b/crypto/src/asn1/BERTaggedObjectParser.cs
index a54e3ce38..c87f6cf9a 100644
--- a/crypto/src/asn1/BERTaggedObjectParser.cs
+++ b/crypto/src/asn1/BERTaggedObjectParser.cs
@@ -3,25 +3,24 @@ using System.IO;
namespace Org.BouncyCastle.Asn1
{
+ [Obsolete("Will be made non-public. Test for and use only Asn1TaggedObjectParser.")]
public class BerTaggedObjectParser
: Asn1TaggedObjectParser
{
- private readonly int m_tagClass;
- private readonly int m_tagNo;
- private readonly bool m_constructed;
- private readonly Asn1StreamParser m_parser;
+ internal readonly int m_tagClass;
+ internal readonly int m_tagNo;
+ internal readonly Asn1StreamParser m_parser;
- internal BerTaggedObjectParser(int tagClass, int tagNo, bool constructed, Asn1StreamParser parser)
+ internal BerTaggedObjectParser(int tagClass, int tagNo, Asn1StreamParser parser)
{
- this.m_tagClass = tagClass;
- this.m_tagNo = tagNo;
- this.m_constructed = constructed;
- this.m_parser = parser;
+ m_tagClass = tagClass;
+ m_tagNo = tagNo;
+ m_parser = parser;
}
- public bool IsConstructed
+ public virtual bool IsConstructed
{
- get { return m_constructed; }
+ get { return true; }
}
public int TagClass
@@ -53,40 +52,39 @@ namespace Org.BouncyCastle.Asn1
return ParseBaseUniversal(declaredExplicit, baseTagNo);
}
- public IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo)
+ public virtual IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo)
{
if (declaredExplicit)
- {
- if (!m_constructed)
- throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+ return m_parser.ParseObject(baseTagNo);
- // TODO[asn1] Alternate parser method specific to this case
- return m_parser.ReadObject();
- }
-
- return m_parser.ReadImplicit(m_constructed, baseTagNo);
+ return m_parser.ParseImplicitConstructedIL(baseTagNo);
}
- public Asn1TaggedObjectParser ParseExplicitBaseTagged()
+ public virtual IAsn1Convertible ParseExplicitBaseObject()
{
- if (!m_constructed)
- throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+ return m_parser.ReadObject();
+ }
- // TODO[asn1] Alternate parser method specific to this case
- return (Asn1TaggedObjectParser)m_parser.ReadObject();
+ public virtual Asn1TaggedObjectParser ParseExplicitBaseTagged()
+ {
+ return m_parser.ParseTaggedObject();
}
- public Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo)
+ public virtual Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo)
{
- return new BerTaggedObjectParser(baseTagClass, baseTagNo, m_constructed, m_parser);
+ // TODO[asn1] Special handling can be removed once ASN1ApplicationSpecificParser types removed.
+ if (Asn1Tags.Application == baseTagClass)
+ return new BerApplicationSpecificParser(baseTagNo, m_parser);
+
+ return new BerTaggedObjectParser(baseTagClass, baseTagNo, m_parser);
}
- public Asn1Object ToAsn1Object()
+ public virtual Asn1Object ToAsn1Object()
{
try
{
- return m_parser.ReadTaggedObject(TagClass, TagNo, IsConstructed);
- }
+ return m_parser.LoadTaggedIL(TagClass, TagNo);
+ }
catch (IOException e)
{
throw new Asn1ParsingException(e.Message);
diff --git a/crypto/src/asn1/BerApplicationSpecificParser.cs b/crypto/src/asn1/BerApplicationSpecificParser.cs
index 899e76ca5..75b7e7632 100644
--- a/crypto/src/asn1/BerApplicationSpecificParser.cs
+++ b/crypto/src/asn1/BerApplicationSpecificParser.cs
@@ -6,14 +6,14 @@ namespace Org.BouncyCastle.Asn1
: BerTaggedObjectParser, IAsn1ApplicationSpecificParser
{
internal BerApplicationSpecificParser(int tagNo, Asn1StreamParser parser)
- : base(Asn1Tags.Application, tagNo, true, parser)
+ : base(Asn1Tags.Application, tagNo, parser)
{
}
public IAsn1Convertible ReadObject()
{
// NOTE: No way to say you're looking for an implicitly-tagged object via IAsn1ApplicationSpecificParser
- return ParseBaseUniversal(true, -1);
- }
+ return ParseExplicitBaseObject();
+ }
}
}
diff --git a/crypto/src/asn1/DLTaggedObjectParser.cs b/crypto/src/asn1/DLTaggedObjectParser.cs
new file mode 100644
index 000000000..307a6342a
--- /dev/null
+++ b/crypto/src/asn1/DLTaggedObjectParser.cs
@@ -0,0 +1,81 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1
+{
+ /**
+ * Parser for definite-length tagged objects.
+ */
+ internal class DLTaggedObjectParser
+ : BerTaggedObjectParser
+ {
+ private readonly bool m_constructed;
+
+ internal DLTaggedObjectParser(int tagClass, int tagNo, bool constructed, Asn1StreamParser parser)
+ : base(tagClass, tagNo, parser)
+ {
+ m_constructed = constructed;
+ }
+
+ public override bool IsConstructed
+ {
+ get { return m_constructed; }
+ }
+
+ public override IAsn1Convertible ParseBaseUniversal(bool declaredExplicit, int baseTagNo)
+ {
+ if (declaredExplicit)
+ {
+ if (!m_constructed)
+ throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+
+ return m_parser.ParseObject(baseTagNo);
+ }
+
+ return m_constructed
+ ? m_parser.ParseImplicitConstructedDL(baseTagNo)
+ : m_parser.ParseImplicitPrimitive(baseTagNo);
+ }
+
+ public override IAsn1Convertible ParseExplicitBaseObject()
+ {
+ if (!m_constructed)
+ throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+
+ return m_parser.ReadObject();
+ }
+
+ public override Asn1TaggedObjectParser ParseExplicitBaseTagged()
+ {
+ if (!m_constructed)
+ throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+
+ return m_parser.ParseTaggedObject();
+ }
+
+ public override Asn1TaggedObjectParser ParseImplicitBaseTagged(int baseTagClass, int baseTagNo)
+ {
+ // TODO[asn1] Special handling can be removed once ASN1ApplicationSpecificParser types removed.
+ if (Asn1Tags.Application == baseTagClass)
+ {
+ // This cast is ensuring the current user-expected return type.
+ return (DLApplicationSpecific)m_parser.LoadTaggedDL(baseTagClass, baseTagNo, m_constructed);
+ }
+
+ return new DLTaggedObjectParser(baseTagClass, baseTagNo, m_constructed, m_parser);
+ }
+
+ public override Asn1Object ToAsn1Object()
+ {
+ try
+ {
+ return m_parser.LoadTaggedDL(TagClass, TagNo, m_constructed);
+ }
+ catch (IOException e)
+ {
+ throw new Asn1ParsingException(e.Message);
+ }
+ }
+ }
+}
+
diff --git a/crypto/src/asn1/DerApplicationSpecific.cs b/crypto/src/asn1/DerApplicationSpecific.cs
index 92443b917..d474034ed 100644
--- a/crypto/src/asn1/DerApplicationSpecific.cs
+++ b/crypto/src/asn1/DerApplicationSpecific.cs
@@ -126,6 +126,11 @@ namespace Org.BouncyCastle.Asn1
return m_taggedObject.ParseBaseUniversal(declaredExplicit, baseTagNo);
}
+ public IAsn1Convertible ParseExplicitBaseObject()
+ {
+ return TaggedObject.ParseExplicitBaseObject();
+ }
+
public Asn1TaggedObjectParser ParseExplicitBaseTagged()
{
return m_taggedObject.ParseExplicitBaseTagged();
@@ -160,7 +165,7 @@ namespace Org.BouncyCastle.Asn1
public IAsn1Convertible ReadObject()
{
// NOTE: No way to say you're looking for an implicitly-tagged object via IAsn1ApplicationSpecificParser
- return m_taggedObject.GetBaseObject();
+ return ParseExplicitBaseObject();
}
public int TagClass
diff --git a/crypto/src/asn1/cms/ContentInfoParser.cs b/crypto/src/asn1/cms/ContentInfoParser.cs
index 541cc0f59..750d8ba7a 100644
--- a/crypto/src/asn1/cms/ContentInfoParser.cs
+++ b/crypto/src/asn1/cms/ContentInfoParser.cs
@@ -13,28 +13,28 @@ namespace Org.BouncyCastle.Asn1.Cms
*/
public class ContentInfoParser
{
- private DerObjectIdentifier contentType;
- private Asn1TaggedObjectParser content;
+ private readonly DerObjectIdentifier m_contentType;
+ private readonly Asn1TaggedObjectParser m_content;
- public ContentInfoParser(
- Asn1SequenceParser seq)
+ public ContentInfoParser(Asn1SequenceParser seq)
{
- contentType = (DerObjectIdentifier)seq.ReadObject();
- content = (Asn1TaggedObjectParser)seq.ReadObject();
+ m_contentType = (DerObjectIdentifier)seq.ReadObject();
+ m_content = (Asn1TaggedObjectParser)seq.ReadObject();
}
public DerObjectIdentifier ContentType
{
- get { return contentType; }
+ get { return m_contentType; }
}
- public IAsn1Convertible GetContent(
- int tag)
+ public IAsn1Convertible GetContent(int tag)
{
- if (content == null)
+ if (null == m_content)
return null;
- return content.GetObjectParser(tag, true);
- }
+ // TODO[cms] Ideally we could enforce the claimed tag
+ //return Asn1Utilities.ParseContextBaseUniversal(content, 0, true, tag);
+ return Asn1Utilities.ParseExplicitContextBaseObject(m_content, 0);
+ }
}
}
diff --git a/crypto/test/src/asn1/test/InputStreamTest.cs b/crypto/test/src/asn1/test/InputStreamTest.cs
index ab5200905..8f29b41ac 100644
--- a/crypto/test/src/asn1/test/InputStreamTest.cs
+++ b/crypto/test/src/asn1/test/InputStreamTest.cs
@@ -77,7 +77,7 @@ namespace Org.BouncyCastle.Asn1.Tests
// TODO Test data has length issues too; needs to be reworked
//DoTestWithByteArray(classCast1, "unknown object encountered: Org.BouncyCastle.Asn1.DerApplicationSpecific");
- DoTestWithByteArray(classCast2, "unknown object encountered: Org.BouncyCastle.Asn1.BerTaggedObjectParser");
+ DoTestWithByteArray(classCast2, "unknown object encountered: Org.BouncyCastle.Asn1.DLTaggedObjectParser");
DoTestWithByteArray(classCast3, "unknown object encountered in constructed OCTET STRING: Org.BouncyCastle.Asn1.DLTaggedObject");
// TODO Error dependent on parser choices; needs to be reworked
|
