public static void Initialize(Asn1Reader asn1Reader, Byte[] raw, Int32 pOffset)
{
Logger.writeLog("Initialize-1");
asn1Reader.IsConstructed = false;
if (raw != null)
{
Logger.writeLog("Initialize-2");
asn1Reader.RawData = raw;
}
Logger.writeLog("Initialize-3");
asn1Reader.Offset = pOffset;
asn1Reader.Tag = asn1Reader.RawData[asn1Reader.Offset];
Logger.writeLog("Initialize-4");
CalculateLength(asn1Reader);
Logger.writeLog("Initialize-5");
// strip possible unnecessary bytes
if (raw != null && asn1Reader.TagLength != asn1Reader.RawData.Length)
{
Logger.writeLog("Initialize-6");
asn1Reader.RawData = raw.Take(asn1Reader.TagLength);
Logger.writeLog("Initialize-7");
}
Logger.writeLog("Initialize-8");
GetTagName(asn1Reader, asn1Reader.Tag);
Logger.writeLog("Initialize-9");
// 0 Tag is reserved for BER and is not available in DER
if (asn1Reader.Tag == 0)
{
Logger.writeLog("Initialize-10");
Logger.writeLog("ERROR-Invalid tag");
return;
//throw new Asn1InvalidTagException(asn1Reader.Offset);
}
Logger.writeLog("Initialize-11");
if (asn1Reader.PayloadLength == 0)
{
Logger.writeLog("Initialize-12");
int rawDataLength = asn1Reader.RawData.Length;
int offsetAndTagLength = asn1Reader.Offset + asn1Reader.TagLength;
if (offsetAndTagLength == rawDataLength)
{
Logger.writeLog("Initialize-13");
asn1Reader.NextOffset = 0;
}
else
{
Logger.writeLog("Initialize-14");
asn1Reader.NextOffset = offsetAndTagLength;
}
Logger.writeLog("Initialize-15");
// TODO check this
if (asn1Reader.currentPosition.LevelEnd == 0 ||
asn1Reader.Offset - asn1Reader.currentPosition.LevelStart + asn1Reader.TagLength == asn1Reader.currentPosition.LevelEnd)
{
Logger.writeLog("Initialize-16");
asn1Reader.NextCurrentLevelOffset = 0;
}
else
{
Logger.writeLog("Initialize-17");
asn1Reader.NextCurrentLevelOffset = asn1Reader.NextOffset;
}
Logger.writeLog("Initialize-18");
//NextCurrentLevelOffset = NextOffset;
return;
}
Logger.writeLog("Initialize-19");
ParseNestedType(asn1Reader);
Logger.writeLog("Initialize-20");
if (asn1Reader.Offset - asn1Reader.currentPosition.LevelStart + asn1Reader.TagLength < asn1Reader.currentPosition.LevelEnd)
{
Logger.writeLog("Initialize-21");
asn1Reader.NextCurrentLevelOffset = asn1Reader.Offset + asn1Reader.TagLength;
}
else
{
Logger.writeLog("Initialize-21");
asn1Reader.NextCurrentLevelOffset = 0;
}
if (asn1Reader.IsConstructed)
{
Logger.writeLog("Initialize-23");
if (asn1Reader.Tag == 3)
{
Logger.writeLog("Initialize-24");
asn1Reader.NextOffset = asn1Reader.PayloadStartOffset + 1;
}
else
{
Logger.writeLog("Initialize-25");
asn1Reader.NextOffset = asn1Reader.PayloadStartOffset;
}
}
else
{
Logger.writeLog("Initialize-26");
if (asn1Reader.Offset + asn1Reader.TagLength < asn1Reader.RawData.Length)
{
Logger.writeLog("Initialize-27");
asn1Reader.NextOffset = asn1Reader.Offset + asn1Reader.TagLength;
}
else
{
Logger.writeLog("Initialize-28");
asn1Reader.NextOffset = 0;
}
}
}
static Asn1Reader Decode(Asn1Reader asn1Reader, Asn1GeneralizedTime asn1GeneralizedTime)
{
Init(asn1Reader, asn1GeneralizedTime);
asn1GeneralizedTime.tagValue = DateTimeUtils.Decode(asn1Reader);
return asn1Reader;
}
static void Init(Asn1Reader asn1Reader, Asn1GeneralizedTime asn1GeneralizedTime)
{
asn1GeneralizedTime.Tag = asn1Reader.Tag;
asn1GeneralizedTime.TagName = asn1Reader.TagName;
asn1GeneralizedTime.RawData = Asn1ReaderT.GetTagRawData(asn1Reader);
}
public static void MoveNextCurrentLevelAndExpectTags(Asn1Reader asn1Reader, params Byte[] expectedTags)
{
MoveAndExpectTypesWithMoveNextCurrentLevel(asn1Reader, expectedTags);
}
public static void Reset(Asn1Reader asn1Reader)
{
asn1Reader.currentPosition = asn1Reader.offsetMap[0];
Initialize(asn1Reader, null, 0);
}
public static Int32 GetNestedNodeCount(Asn1Reader asn1Reader)
{
return asn1Reader.IsConstructed ? asn1Reader.childCount : 0;
}
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();
}
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 Byte[] GetPayload(Asn1Reader asn1Reader)
{
return(Neo.SmartContract.Framework.Helper.Range(asn1Reader.RawData, asn1Reader.PayloadStartOffset, asn1Reader.PayloadLength));
// return asn1Reader.RawData.Skip(asn1Reader.PayloadStartOffset).Take(asn1Reader.PayloadLength).ToArray();
}
static String DecodeGeneralizedTime(Asn1Reader asn)
{
DateTime dt = Asn1GeneralizedTime.Decode(asn);
return(dt.ToShortDateString() + " " + dt.ToShortTimeString());
}
