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); }