void m_decode(Byte[] rawData)
{
try {
Type = X509CrlType.BaseCrl;
var signedInfo = new SignedContentBlob(rawData, ContentBlobType.SignedBlob);
// signature and alg
signature = signedInfo.Signature.Value;
sigUnused = signedInfo.Signature.UnusedBits;
SignatureAlgorithm = signedInfo.SignatureAlgorithm.AlgorithmId;
// tbs
Asn1Reader asn = new Asn1Reader(signedInfo.ToBeSignedData);
if (!asn.MoveNext())
{
throw new Asn1InvalidTagException();
}
// version
if (asn.Tag == (Byte)Asn1Type.INTEGER)
{
Version = (Int32)Asn1Utils.DecodeInteger(asn.GetTagRawData()) + 1;
asn.MoveNextCurrentLevel();
}
else
{
Version = 1;
}
// hash algorithm
var h = new AlgorithmIdentifier(asn.GetTagRawData());
if (h.AlgorithmId.Value != SignatureAlgorithm.Value)
{
throw new CryptographicException("Algorithm mismatch.");
}
if (!asn.MoveNextCurrentLevel())
{
throw new Asn1InvalidTagException();
}
// issuer
IssuerName = new X500DistinguishedName(asn.GetTagRawData());
// NextUpdate, RevokedCerts and Extensions are optional. Ref: RFC5280, p.118
if (!asn.MoveNextCurrentLevel())
{
throw new Asn1InvalidTagException();
}
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
ThisUpdate = new Asn1UtcTime(asn.GetTagRawData()).Value;
break;
case (Byte)Asn1Type.GeneralizedTime:
ThisUpdate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
default:
throw new Asn1InvalidTagException();
}
if (!asn.MoveNextCurrentLevel())
{
return;
}
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
case (Byte)Asn1Type.GeneralizedTime:
switch (asn.Tag)
{
case (Byte)Asn1Type.UTCTime:
NextUpdate = new Asn1UtcTime(asn.GetTagRawData()).Value;
break;
case (Byte)Asn1Type.GeneralizedTime:
NextUpdate = Asn1Utils.DecodeGeneralizedTime(asn.GetTagRawData());
break;
default:
throw new Asn1InvalidTagException();
}
if (!asn.MoveNextCurrentLevel())
{
return;
}
if (asn.Tag == 48)
{
getRevCerts(asn);
if (!asn.MoveNextCurrentLevel())
{
return;
}
getExts(asn);
}
else
{
getExts(asn);
}
break;
case 48:
if (asn.Tag == 48)
{
getRevCerts(asn);
if (!asn.MoveNextCurrentLevel())
{
return;
}
getExts(asn);
}
else
{
getExts(asn);
}
break;
default:
getExts(asn);
break;
}
} catch (Exception e) {
throw new CryptographicException("Cannot find the requested object.", e);
}
}
static void Init(Asn1Reader asn1Reader, Asn1GeneralizedTime asn1GeneralizedTime)
{
asn1GeneralizedTime.Tag = asn1Reader.Tag;
asn1GeneralizedTime.TagName = asn1Reader.TagName;
asn1GeneralizedTime.RawData = Asn1ReaderT.GetTagRawData(asn1Reader);
}
static void ParseNestedType(Asn1Reader asn1Reader)
{
// processing rules (assuming zero-based bits):
// if bit 5 is set to "1", or the type is SEQUENCE/SET -- the type is constructed. Unroll nested types.
// if bit 5 is set to "0", attempt to resolve nested types only for UNIVERSAL tags.
Logger.writeLog("ParseNestedType-1");
if (asn1Reader.excludedTags.HasKey(asn1Reader.Tag) || asn1Reader.PayloadLength < 2)
{
Logger.writeLog("ParseNestedType-2");
return;
}
Logger.writeLog("ParseNestedType-3");
Int64 pstart = asn1Reader.PayloadStartOffset;
Int32 plength = asn1Reader.PayloadLength;
Storage.Put(Storage.CurrentContext, "asn1Reader.Tag", asn1Reader.Tag);
Storage.Put(Storage.CurrentContext, "pstart", pstart);
Storage.Put(Storage.CurrentContext, "plength", plength);
if (asn1Reader.Tag == 3)
{
Logger.writeLog("ParseNestedType-4");
pstart = asn1Reader.PayloadStartOffset + 1;
plength = asn1Reader.PayloadLength - 1;
Logger.writeLog("ParseNestedType-5");
}
if (asn1Reader.multiNestedTypes.HasKey(asn1Reader.Tag) ||
(asn1Reader.Tag & (Byte)Asn1Class.CONSTRUCTED) > 0)
{
Logger.writeLog("ParseNestedType-6");
asn1Reader.IsConstructed = true;
if (!asn1Reader.offsetMap.HasKey(pstart))
{
Logger.writeLog("ParseNestedType-7");
PredictResult predictResult = Predict(asn1Reader, pstart, plength, true);
asn1Reader.childCount = predictResult.estimatedChildCount;
Logger.writeLog("ParseNestedType-8");
}
Logger.writeLog("ParseNestedType-9");
asn1Reader.isTaggedConstructed = false;
return;
}
Logger.writeLog("ParseNestedType-10");
if (asn1Reader.Tag > 0 && asn1Reader.Tag < (Byte)Asn1Type.TAG_MASK)
{
Logger.writeLog("ParseNestedType-11");
PredictResult predictResult = Predict(asn1Reader, pstart, plength, false);
Logger.writeLog("ParseNestedType-12");
asn1Reader.childCount = predictResult.estimatedChildCount;
asn1Reader.IsConstructed = predictResult.result;
Logger.writeLog("ParseNestedType-13");
// reiterate again and build map for children
if (asn1Reader.IsConstructed && !asn1Reader.offsetMap.HasKey(pstart))
{
Logger.writeLog("ParseNestedType-14");
PredictResult predictResultOther = Predict(asn1Reader, pstart, plength, false);
asn1Reader.childCount = predictResultOther.estimatedChildCount;
Logger.writeLog("ParseNestedType-15");
}
Logger.writeLog("ParseNestedType-16");
}
Logger.writeLog("ParseNestedType-17");
asn1Reader.isTaggedConstructed = false;
}
public static Int32 GetNestedNodeCount(Asn1Reader asn1Reader)
{
return(asn1Reader.IsConstructed ? asn1Reader.childCount : 0);
}
public static void Reset(Asn1Reader asn1Reader)
{
asn1Reader.currentPosition = asn1Reader.offsetMap[0];
Initialize(asn1Reader, null, 0);
}
static String DecodeGeneralizedTime(Asn1Reader asn)
{
DateTime dt = new Asn1GeneralizedTime(asn).Value;
return(dt.ToString("dd.MM.yyyy hh:mm:ss"));
}
/// <summary>
/// Initializes a new instance of <strong>Asn1DateTime</strong> class from an existing
/// <see cref="Asn1Reader"/> object.
/// </summary>
/// <param name="asn"><see cref="Asn1Reader"/> object in the position that represents ASN.1 date/time object.</param>
protected Asn1DateTime(Asn1Reader asn) : base(asn)
{
}
void decodeListIdentifier(Asn1Reader asn)
{
ListIdentifier = Encoding.Unicode.GetString(asn.GetPayload()).TrimEnd('\0');
}
void decodeSequenceNumber(Asn1Reader asn)
{
sequenceNumber = new Asn1Integer(asn.GetTagRawData()).Value;
SequenceNumber = AsnFormatter.BinaryToString(asn.GetPayload());
}
void decodeTbsResponse(Asn1Reader tbsResponseData)
{
tbsResponseData.MoveNext();
if (tbsResponseData.Tag == 160)
{
//Asn1Reader aversion = new Asn1Reader(tbsResponseData.RawData, tbsResponseData.PayloadStartOffset);
Asn1Reader aversion = new Asn1Reader(tbsResponseData);
aversion.MoveNext();
Version = aversion.GetPayload()[0] + 1;
tbsResponseData.MoveNextCurrentLevel();
}
else
{
Version = 1;
}
//responderID
switch (tbsResponseData.Tag)
{
case 161:
ResponderNameId = new X500DistinguishedName(tbsResponseData.GetPayload());
tbsResponseData.MoveNextCurrentLevel();
break;
case 162:
tbsResponseData.MoveNext();
StringBuilder SB = new StringBuilder();
foreach (Byte element in tbsResponseData.GetPayload())
{
SB.Append(element.ToString("X2"));
}
ResponderKeyId = SB.ToString();
tbsResponseData.MoveNext();
break;
default:
throw new Exception("Invalid tag at responderID. Expected 161 (byName) or 162 (byKey).");
}
//tbsResponseData.MoveNextCurrentLevel();
ProducedAt = Asn1Utils.DecodeGeneralizedTime(tbsResponseData.GetTagRawData());
if (DateTime.Now < ProducedAt.AddMinutes(-10))
{
ResponseErrorInformation += (Int32)OCSPResponseComplianceError.ResponseNotTimeValid;
}
//responses
tbsResponseData.MoveNext();
//single response
Asn1Reader responses = new Asn1Reader(tbsResponseData.GetTagRawData());
responses.MoveNext();
Int32 Offset;
Responses = new OCSPSingleResponseCollection();
do
{
Asn1Reader response = new Asn1Reader(responses);
Offset = response.NextCurrentLevelOffset;
Responses.Add(new OCSPSingleResponse(response));
if (Request != null)
{
foreach (OCSPSingleResponse item in Responses)
{
Boolean certidmatch = Request.RequestList.Any(x => x.CertId.Equals(item.CertId));
if (!certidmatch)
{
ResponseErrorInformation += (Int32)OCSPResponseComplianceError.CertIdMismatch;
}
}
}
} while (Offset != 0);
if (tbsResponseData.NextCurrentLevelOffset != 0)
{
tbsResponseData.MoveNextCurrentLevel();
if (tbsResponseData.Tag == 161)
{
X509ExtensionCollection exts = new X509ExtensionCollection();
exts.Decode(tbsResponseData.GetPayload());
foreach (X509Extension item in exts)
{
_listExtensions.Add(CryptographyUtils.ConvertExtension(item));
if (_listExtensions[_listExtensions.Count - 1].Oid.Value == X509CertExtensions.X509OcspNonce)
{
NonceReceived = true;
NonceValue = _listExtensions[_listExtensions.Count - 1].Format(false);
}
}
}
else
{
throw new Exception("Unexpected tag at responseExtensions. Expected 161.");
}
}
}
void m_decode(Asn1Reader asn)
{
Value = asn.GetPayload()[0] > 0;
}
static void ParseNestedType(Asn1Reader asn1Reader)
{
// processing rules (assuming zero-based bits):
// if bit 5 is set to "1", or the type is SEQUENCE/SET -- the type is constructed. Unroll nested types.
// if bit 5 is set to "0", attempt to resolve nested types only for UNIVERSAL tags.
Logger.writeLog("ParseNestedType-1");
Logger.writeLog(asn1Reader.Tag + "");
Logger.writeLog("ParseNestedType-1.0");
Logger.writeLog(asn1Reader.PayloadLength + "");
bool tag = asn1Reader.excludedTags[asn1Reader.Tag];
Logger.writeLog("ParseNestedType-1.1");
if (asn1Reader.excludedTags[asn1Reader.Tag] == true || asn1Reader.PayloadLength < 2)
{
Logger.writeLog("ParseNestedType-2");
return;
}
Int64 pstart = asn1Reader.PayloadStartOffset;
Int32 plength = asn1Reader.PayloadLength;
if (asn1Reader.Tag == 3)
{
Logger.writeLog("ParseNestedType-3");
pstart = asn1Reader.PayloadStartOffset + 1;
plength = asn1Reader.PayloadLength - 1;
}
Logger.writeLog("ParseNestedType-4");
if (asn1Reader.multiNestedTypes[asn1Reader.Tag] == true || (asn1Reader.Tag & (Byte)Asn1Class.CONSTRUCTED) > 0)
{
Logger.writeLog("ParseNestedType-5");
asn1Reader.IsConstructed = true;
if (asn1Reader.offsetMap[pstart] != null)
{
Logger.writeLog("ParseNestedType-6");
PredictResult predictResult = Predict(asn1Reader, pstart, plength, true);
asn1Reader.childCount = predictResult.estimatedChildCount;
}
Logger.writeLog("ParseNestedType-7");
asn1Reader.isTaggedConstructed = false;
return;
}
Logger.writeLog("ParseNestedType-8");
if (asn1Reader.Tag > 0 && asn1Reader.Tag < (Byte)Asn1Type.TAG_MASK)
{
Logger.writeLog("ParseNestedType-9");
PredictResult predictResult = Predict(asn1Reader, pstart, plength, false);
Logger.writeLog("ParseNestedType-10");
asn1Reader.childCount = predictResult.estimatedChildCount;
asn1Reader.IsConstructed = predictResult.result;
// reiterate again and build map for children
if (asn1Reader.IsConstructed && asn1Reader.offsetMap[pstart] == null)
{
Logger.writeLog("ParseNestedType-11");
PredictResult predictResultOther = Predict(asn1Reader, pstart, plength, false);
Logger.writeLog("ParseNestedType-12");
asn1Reader.childCount = predictResultOther.estimatedChildCount;
}
}
Logger.writeLog("ParseNestedType-13");
asn1Reader.isTaggedConstructed = false;
}
internal virtual bool TryReadAlgorithmIdentifier(
ref Asn1Reader reader,
out ReadOnlySpan <byte> nonce)
{
throw Error.NotSupported_Operation();
}
void getRevCerts(Asn1Reader asn)
{
RevokedCertificates.Decode(asn.GetTagRawData());
RevokedCertificates.Close();
}
public Asn1Lite(Asn1Reader asn)
{
initialize(asn);
Deepness = 0;
Path = String.Empty;
}
void decodeAlgId(Asn1Reader asn)
{
var algId = new AlgorithmIdentifier(asn.GetTagRawData());
SubjectAlgorithm = algId.AlgorithmId;
}
static String DecodeUTF8String(Asn1Reader asn)
{
return(Encoding.UTF8.GetString(asn.RawData, asn.PayloadStartOffset, asn.PayloadLength));
}
void getVersion(Asn1Reader asn)
{
asn.MoveNextAndExpectTags((Byte)Asn1Type.INTEGER);
Version = (Int32)(Asn1Utils.DecodeInteger(asn.GetTagRawData()) + 1);
}
void m_decode(Asn1Reader asn)
{
Value = new BigInteger(asn.GetPayload().Reverse().ToArray());
}
void getPublicKey(Asn1Reader asn)
{
asn.MoveNextCurrentLevel();
PublicKey = PublicKeyExtensions.FromRawData(asn.GetTagRawData());
}
public static Asn1Reader FromRawData(byte[] rawData)
{
Asn1Reader asn1Reader = FromRawData(rawData, 0);
return(asn1Reader);
}
public Asn1Node(Asn1Reader asn, IAsn1TreeSource source) : base(source)
{
initialize(asn);
}
public static void MoveNextCurrentLevelAndExpectTags(Asn1Reader asn1Reader, params Byte[] expectedTags)
{
MoveAndExpectTypesWithMoveNextCurrentLevel(asn1Reader, expectedTags);
}
void m_decode(Asn1Reader asn)
{
Value = Encoding.UTF32.GetString(asn.GetPayload().Reverse().ToArray());
}
static Asn1Reader Decode(Asn1Reader asn1Reader, Asn1GeneralizedTime asn1GeneralizedTime)
{
Init(asn1Reader, asn1GeneralizedTime);
asn1GeneralizedTime.tagValue = DateTimeUtils.Decode(asn1Reader);
return(asn1Reader);
}
void m_decode(Byte[] rawData)
{
Asn1Reader asn = new Asn1Reader(rawData);
asn.MoveNext();
if (asn.PayloadLength == 0)
{
return;
}
do
{
Byte[] altNames;
switch (asn.Tag)
{
case 0xA0:
Asn1Reader distName = new Asn1Reader(asn.GetPayload());
do
{
switch (distName.Tag)
{
case 0xA0:
// full name
altNames = Asn1Utils.Encode(distName.GetPayload(), 48);
FullName = new X509AlternativeNameCollection();
FullName.Decode(altNames);
break;
case 0xA1:
// relative to issuer name
Byte[] relativeName = Asn1Utils.Encode(distName.GetPayload(), 48);
RelativeToIssuerName = new X500DistinguishedName(relativeName);
break;
default:
throw new InvalidDataException("The data is invalid");
}
} while (distName.MoveNextCurrentLevel());
break;
case 0xA1:
// reasons
Asn1BitString bs = new Asn1BitString(asn.GetPayload());
if (bs.Value[0] == 0)
{
Reasons = X509RevocationReasons.Unspecified;
break;
}
Byte mask = 1;
do
{
if ((bs.Value[0] & mask) > 0)
{
switch (mask)
{
case 1: Reasons += (Int32)X509RevocationReasons.AACompromise; break;
case 2: Reasons += (Int32)X509RevocationReasons.PrivilegeWithdrawn; break;
case 4: Reasons += (Int32)X509RevocationReasons.CertificateHold; break;
case 8: Reasons += (Int32)X509RevocationReasons.CeaseOfOperation; break;
case 16: Reasons += (Int32)X509RevocationReasons.Superseded; break;
case 32: Reasons += (Int32)X509RevocationReasons.ChangeOfAffiliation; break;
case 64: Reasons += (Int32)X509RevocationReasons.CACompromise; break;
case 128: Reasons += (Int32)X509RevocationReasons.KeyCompromise; break;
}
}
mask <<= 1;
} while (mask != 128);
break;
case 0xA2:
// crl issuer
altNames = Asn1Utils.Encode(asn.GetPayload(), 48);
CRLIssuer = new X509AlternativeNameCollection();
CRLIssuer.Decode(altNames);
break;
default:
throw new InvalidDataException("The data is invalid.");
}
} while (asn.MoveNextCurrentLevel());
RawData = rawData;
}
public static void Initialize(Asn1Reader asn1Reader, Byte[] raw, Int32 pOffset)
{
asn1Reader.IsConstructed = false;
if (raw != null)
{
asn1Reader.RawData = raw;
}
asn1Reader.Offset = pOffset;
asn1Reader.Tag = asn1Reader.RawData[asn1Reader.Offset];
CalculateLength(asn1Reader);
// strip possible unnecessary bytes
if (raw != null && asn1Reader.TagLength != asn1Reader.RawData.Length)
{
asn1Reader.RawData = raw.Take(asn1Reader.TagLength);
}
GetTagName(asn1Reader, asn1Reader.Tag);
// 0 Tag is reserved for BER and is not available in DER
if (asn1Reader.Tag == 0)
{
Logger.writeLog("ERROR-Invalid tag");
//throw new Asn1InvalidTagException(asn1Reader.Offset);
}
if (asn1Reader.PayloadLength == 0)
{
int rawDataLength = asn1Reader.RawData.Length;
int offsetAndTagLength = asn1Reader.Offset + asn1Reader.TagLength;
if (offsetAndTagLength == rawDataLength)
{
asn1Reader.NextOffset = 0;
}
else
{
asn1Reader.NextOffset = offsetAndTagLength;
}
// TODO check this
if (asn1Reader.currentPosition.LevelEnd == 0 ||
asn1Reader.Offset - asn1Reader.currentPosition.LevelStart + asn1Reader.TagLength == asn1Reader.currentPosition.LevelEnd)
{
asn1Reader.NextCurrentLevelOffset = 0;
}
else
{
asn1Reader.NextCurrentLevelOffset = asn1Reader.NextOffset;
}
//NextCurrentLevelOffset = NextOffset;
return;
}
ParseNestedType(asn1Reader);
if (asn1Reader.Offset - asn1Reader.currentPosition.LevelStart + asn1Reader.TagLength < asn1Reader.currentPosition.LevelEnd)
{
asn1Reader.NextCurrentLevelOffset = asn1Reader.Offset + asn1Reader.TagLength;
}
else
{
asn1Reader.NextCurrentLevelOffset = 0;
}
if (asn1Reader.IsConstructed)
{
if (asn1Reader.Tag == 3)
{
asn1Reader.NextOffset = asn1Reader.PayloadStartOffset + 1;
}
else
{
asn1Reader.NextOffset = asn1Reader.PayloadStartOffset;
}
}
else
{
if (asn1Reader.Offset + asn1Reader.TagLength < asn1Reader.RawData.Length)
{
asn1Reader.NextOffset = asn1Reader.Offset + asn1Reader.TagLength;
}
else
{
asn1Reader.NextOffset = 0;
}
}
}
void m_decode(Asn1Reader asn)
{
Value = Encoding.BigEndianUnicode.GetString(asn.GetPayload());
}
public static Byte[] GetTagRawData(Asn1Reader asn1Reader)
{
return(Neo.SmartContract.Framework.Helper.Range(asn1Reader.RawData, asn1Reader.Offset, asn1Reader.TagLength));
// return asn1Reader.RawData.Skip(asn1Reader.Offset).Take(asn1Reader.TagLength).ToArray();
}
public static bool GetOpaqueContent(Stream inputStream, Stream outputStream)
{
bool result = false;
int num = 0;
using (Asn1Reader asn1Reader = new Asn1Reader(inputStream))
{
while (asn1Reader.ReadNext() && asn1Reader.EncodingType == EncodingType.Sequence)
{
if (!asn1Reader.ReadFirstChild() || asn1Reader.EncodingType != EncodingType.ObjectIdentifier)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected ContentType=EncodingType.ObjectIdentifier", ++num);
}
else if (asn1Reader.ReadValueAsOID() != OID.RSASignedData)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected RSA_signedData OID", ++num);
}
else if (!asn1Reader.ReadNextSibling() || asn1Reader.TagClass != TagClass.Context || asn1Reader.TagNumber != 0)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected content tag", ++num);
}
else if (!asn1Reader.ReadFirstChild() || asn1Reader.EncodingType != EncodingType.Sequence)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected EncodingType.Sequence", ++num);
}
else if (!asn1Reader.ReadFirstChild() || asn1Reader.EncodingType != EncodingType.Integer)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected version number", ++num);
}
else if (!asn1Reader.ReadNextSibling() || asn1Reader.EncodingType != EncodingType.Set)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected digest algorithm set", ++num);
}
else if (!asn1Reader.ReadNextSibling() || asn1Reader.EncodingType != EncodingType.Sequence)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected content tag", ++num);
}
else if (!asn1Reader.ReadFirstChild() || asn1Reader.EncodingType != EncodingType.ObjectIdentifier)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected ContentType = EncodingType.ObjectIdentifier for SignedData", ++num);
}
else if (asn1Reader.ReadValueAsOID() != OID.RSAData)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected RSA_Data OID", ++num);
}
else if (!asn1Reader.ReadNextSibling())
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find any content in S/MIME blob", ++num);
}
else if (asn1Reader.TagClass != TagClass.Context || asn1Reader.TagNumber != 0)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected tag class or value for S/MIME blob", ++num);
}
else if (!asn1Reader.ReadFirstChild() || asn1Reader.EncodingType != EncodingType.OctetString)
{
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected EncodingType for S/MIME blob", ++num);
}
else
{
BufferPoolCollection.BufferSize bufferSize = BufferPoolCollection.BufferSize.Size20K;
BufferPool bufferPool = BufferPoolCollection.AutoCleanupCollection.Acquire(bufferSize);
byte[] array = null;
try
{
array = bufferPool.Acquire();
do
{
if (!asn1Reader.IsConstructedTag)
{
for (;;)
{
int num2 = asn1Reader.ReadBytesValue(array, 0, array.Length);
if (num2 == 0)
{
break;
}
outputStream.Write(array, 0, num2);
result = true;
}
}
asn1Reader.ReadNext();
}while (asn1Reader.EncodingType == EncodingType.OctetString);
continue;
}
finally
{
if (array != null)
{
bufferPool.Release(array);
}
}
}
return(result);
}
StorageGlobals.ContextTraceDebug <int>(ExTraceGlobals.CcInboundMimeTracer, "InboundMimeConverter.GetOpaqueContent ({0}): did not find expected ContentInfo=EncodingType.Sequence", ++num);
}
return(result);
}
