static void GetTagName(Asn1Data asn1Data, Byte tag) { asn1Data.TagName = "undefined"; /* * Asn1Type type = ((Asn1Type)(tag & 31)); * if ((tag & (Byte)Asn1Class.PRIVATE) != 0) { * switch (tag & (Byte)Asn1Class.PRIVATE) { * case (Byte)Asn1Class.CONTEXT_SPECIFIC: * asn1Data.TagName = "CONTEXT SPECIFIC (" + (tag & 31) + ")"; * asn1Data.isTaggedConstructed = (tag & (Byte)Asn1Class.CONSTRUCTED) > 0; * break; * case (Byte)Asn1Class.APPLICATION: * asn1Data.TagName = "APPLICATION (" + (tag & 31) + ")"; * break; * case (Byte)Asn1Class.PRIVATE: * asn1Data.TagName = "PRIVATE (" + (tag & 31) + ")"; * break; * case (Byte)Asn1Class.CONSTRUCTED: * asn1Data.TagName = "CONSTRUCTED (" + (tag & 31) + ")"; * break; * } * } else { * asn1Data.TagName = ((Asn1Type)(tag & 31))+""; * }*/ }
static Int64 CalculatePredictLength(Asn1Data asn1Data, Int64 offset) { if (offset + 1 >= asn1Data.RawData.Length || offset < 0) { return(Int32.MaxValue); } if (asn1Data.RawData[offset + 1] < 128) { return(asn1Data.RawData[offset + 1] + 2); } Int32 lengthbytes = asn1Data.RawData[offset + 1] - 128; // max length can be encoded by using 4 bytes. if (lengthbytes > 4) { return(Int32.MaxValue); } Int32 ppayloadLength = asn1Data.RawData[offset + 2]; for (Int64 i = offset + 3; i < offset + 2 + lengthbytes; i++) { ppayloadLength = (ppayloadLength << 8) | asn1Data.RawData[i]; } // 2 -- transitional + tag return(ppayloadLength + lengthbytes + 2); }
static void CalculateLength(Asn1Data asn1Data) { if (asn1Data.RawData[asn1Data.Offset + 1] < 128) { asn1Data.PayloadStartOffset = asn1Data.Offset + 2; asn1Data.PayloadLength = asn1Data.RawData[asn1Data.Offset + 1]; asn1Data.TagLength = asn1Data.PayloadLength + 2; } else { Int32 lengthbytes = asn1Data.RawData[asn1Data.Offset + 1] - 128; // max length can be encoded by using 4 bytes. if (lengthbytes > 4) { Logger.writeLog("ERROR-Data length is too large."); // throw new OverflowException("Data length is too large."); } asn1Data.PayloadStartOffset = asn1Data.Offset + 2 + lengthbytes; asn1Data.PayloadLength = asn1Data.RawData[asn1Data.Offset + 2]; for (Int32 i = asn1Data.Offset + 3; i < asn1Data.PayloadStartOffset; i++) { asn1Data.PayloadLength = (asn1Data.PayloadLength << 8) | asn1Data.RawData[i]; } asn1Data.TagLength = asn1Data.PayloadLength + lengthbytes + 2; } }
public static Asn1Data FromRawData(Byte[] rawData, Int32 offset) { Logger.writeLog("(Start)FromRawData - Byte[],Int32"); if (rawData == null) { Logger.writeLog("rawData is null"); // throw new ArgumentNullException("rawData"); } if (rawData.Length < 2) { Logger.writeLog("ERROR-rawData.Length must be upper than 2"); //throw new Win32Exception("Invalid Data"); } Logger.writeLog("Constructing asn1Data object"); Asn1Data asn1Data = new Asn1Data(); Logger.writeLog("Constructed asn1Data object"); initMembers(asn1Data); Logger.writeLog("Calling Initialize with asn1Data,rawData and offset"); Initialize(asn1Data, rawData, offset); Logger.writeLog("Called Initialize with asn1Data,rawData and offset"); Logger.writeLog("(End)FromRawData - Byte[],Int32"); return(asn1Data); }
public static void initMembers(Asn1Data asn1Data) { Logger.writeLog("(Start)initMembers"); asn1Data.excludedTags = new Map <byte, bool>(); asn1Data.offsetMap = new Map <Int64, AsnInternalMap>(); asn1Data.multiNestedTypes = new Map <byte, bool>(); asn1Data.tmpHTable = new Map <byte, bool>(); Logger.writeLog("(End)initMembers"); Logger.writeLog("Initializing _excludedTags map"); asn1Data.excludedTags[0] = true; asn1Data.excludedTags[1] = true; asn1Data.excludedTags[2] = true; asn1Data.excludedTags[5] = true; asn1Data.excludedTags[6] = true; asn1Data.excludedTags[9] = true; asn1Data.excludedTags[10] = true; asn1Data.excludedTags[13] = true; Logger.writeLog("Initialized _excludedTags map"); Logger.writeLog("Initializing multiNestedTypes"); asn1Data.multiNestedTypes[(Byte)Asn1Type.SEQUENCE] = true; asn1Data.multiNestedTypes[(Byte)((Byte)Asn1Type.SEQUENCE | (Byte)Asn1Class.CONSTRUCTED)] = true; asn1Data.multiNestedTypes[(Byte)Asn1Type.SET] = true; asn1Data.multiNestedTypes[(Byte)((Byte)Asn1Type.SET | (Byte)Asn1Class.CONSTRUCTED)] = true; Logger.writeLog("Initialized multiNestedTypes"); Logger.writeLog("Constructing AsnInternalMap object and assigning to asn1Data.currentPosition"); asn1Data.currentPosition = new AsnInternalMap(); Logger.writeLog("Constructed AsnInternalMap object and assigning to asn1Data.currentPosition"); Logger.writeLog("Setting asn1Data._offsetMap[0]"); asn1Data.offsetMap[0] = asn1Data.currentPosition; Logger.writeLog("Finished Setting asn1Data._offsetMap[0]"); }
static PredictResult Predict(Asn1Data asn1Data, Int64 start, Int32 projectedLength, bool assignMap) { Int64 levelStart = start; Int64 sum = 0; PredictResult predictResult = new PredictResult(); predictResult.estimatedChildCount = 0; do { if (start < 0 || start >= asn1Data.RawData.Length || asn1Data.RawData[start] == 0) { predictResult.result = false; return(predictResult); } Int64 pl = CalculatePredictLength(asn1Data, start); sum += pl; if (assignMap && sum <= projectedLength) { asn1Data.offsetMap[start] = new AsnInternalMap { LevelStart = levelStart, LevelEnd = projectedLength }; } start += pl; predictResult.estimatedChildCount++; } while (sum < projectedLength); if (sum != projectedLength) { predictResult.estimatedChildCount = 0; } predictResult.result = sum == projectedLength; return(predictResult); }
public static Asn1Data ParseFromRawData(byte[] rawData) { Logger.writeLog("(Start)FromRawData - Byte[]"); Asn1Data asn1Data = FromRawData(rawData, 0); Logger.writeLog("(End)FromRawData - Byte[]"); return(asn1Data); }
public static Byte[] GetHeader(Asn1Data asn1Data) { return(Neo.SmartContract.Framework.Helper.Range(asn1Data.RawData, asn1Data.Offset, asn1Data.PayloadStartOffset - asn1Data.Offset)); //return asn1Data.RawData.Take(asn1Data.PayloadStartOffset - asn1Data.Offset); //Byte[] newArray = new Byte[asn1Data.PayloadStartOffset - asn1Data.Offset]; // Array.Copy(asn1Data.RawData, 0, newArray, asn1Data.Offset, asn1Data.PayloadStartOffset - asn1Data.Offset); // return newArray; // return asn1Data.RawData.Skip(asn1Data.Offset).Take(asn1Data.PayloadStartOffset - asn1Data.Offset).ToArray(); }
public static Int32 BuildOffsetMap(Asn1Data asn1Data) { Reset(asn1Data); do { } while (MoveNext(asn1Data)); Reset(asn1Data); return(1);//asn1Data._offsetMap.Keys.Size(); }
public static Boolean MoveNextCurrentLevel(Asn1Data asn1Data) { if (asn1Data.NextCurrentLevelOffset == 0) { return(false); } asn1Data.currentPosition = asn1Data.offsetMap[asn1Data.NextCurrentLevelOffset]; Initialize(asn1Data, null, asn1Data.NextCurrentLevelOffset); return(true); }
public static Boolean MoveNext(Asn1Data asn1Data) { if (asn1Data.NextOffset == 0) { return(false); } //projectedIterationSize = _offsetMap[NextOffset]; asn1Data.currentPosition = asn1Data.offsetMap[asn1Data.NextOffset]; Initialize(asn1Data, null, asn1Data.NextOffset); return(true); }
public static long DecodeUTCTime(Byte[] rawData) { if (rawData == null) { Logger.writeLog("ERROR-raw data is null"); return(-1); } Asn1Data asn1Data = Asn1Parser.ParseFromRawData(rawData); return((new Asn1UtcTime(asn)).Value); }
/*void m_decode(Byte[] rawData) { * asn1Data asn = new asn1Data(rawData); * Init(asn); * tagValue = DateTimeUtils.Decode(asn, out zoneInfo); * }*/ /* protected void Init(asn1Data asn) * { * Tag = asn.Tag; * TagName = asn.TagName; * RawData = asn.GetTagRawData(); * }*/ public static long Decode(Asn1Data asn1Data) { if (asn1Data == null) { throw new ArgumentNullException("asn"); } if (asn1Data.Tag != (Byte)Asn1Type.Generalizedtime) { //throw new Asn1InvalidTagException("Invalid Type" + tagName); } return(DateTimeUtils.Decode(asn1Data)); }
public static Boolean MoveToPoisition(Asn1Data asn1Data, Int32 newPosition) { if (asn1Data.offsetMap == null) { throw new InvalidOperationException(); } if (asn1Data.offsetMap[newPosition] == null) { return(false); } asn1Data.currentPosition = asn1Data.offsetMap[newPosition]; Initialize(asn1Data, null, newPosition); return(true); }
/*void m_decode(Byte[] rawData) { * asn1Data asn = new asn1Data(rawData); * Init(asn); * tagValue = DateTimeUtils.Decode(asn, out zoneInfo); * }*/ /* protected void Init(asn1Data asn) * { * Tag = asn.Tag; * TagName = asn.TagName; * RawData = asn.GetTagRawData(); * }*/ public static long Decode(Asn1Data asn1Data) { if (asn1Data == null) { Logger.writeLog("Invalid asn1 Data - null"); return(-1); } if (asn1Data.Tag != (Byte)Asn1Type.Generalizedtime) { Logger.writeLog("Unsupported Tag"); return(-1); } return(DateTimeUtils.Decode(asn1Data)); }
public static Boolean MoveNext(Asn1Data asn1Data) { Logger.writeLog("MoveNext-1"); if (asn1Data.NextOffset == 0) { Logger.writeLog("MoveNext-2"); return(false); } //projectedIterationSize = _offsetMap[NextOffset]; Logger.writeLog("MoveNext-3"); asn1Data.currentPosition = asn1Data.offsetMap[asn1Data.NextOffset]; Logger.writeLog("MoveNext-4"); Initialize(asn1Data, null, asn1Data.NextOffset); Logger.writeLog("MoveNext-5"); return(true); }
public static long DecodeDateTime(Byte[] rawData) { Asn1Data asn1Data = Asn1Parser.ParseFromRawData(rawData); switch (asn1Data.Tag) { case (Byte)Asn1Type.UTCTime: return(Asn1UtcTimeParser.Decode(rawData)); case (Byte)Asn1Type.Generalizedtime: return(DecodeGeneralizedTime(rawData)); default: { return(-1); } } }
public static byte[] DecodeDateTime(Asn1Data asn1Data) { switch (asn1Data.Tag) { case (Byte)Asn1Type.UTCTime: return(Asn1UtcTimeParser.Decode(asn1Data)); case (Byte)Asn1Type.Generalizedtime: return(Asn1GeneralizedTimeParser.Decode(asn1Data)); default: { //todo: Handle exceptions return(null); } } }
public static Asn1Data FromRawData(Byte[] rawData, Int32 offset) { if (rawData == null) { Logger.writeLog("ERROR-rawData is null"); return(null); } if (rawData.Length < 2) { Logger.writeLog("ERROR-rawData.Length must be upper than 2"); return(null); } Asn1Data asn1Data = new Asn1Data(); InitMemberDefaultValues(asn1Data); Initialize(asn1Data, rawData, offset); return(asn1Data); }
static PredictResult Predict(Asn1Data asn1Data, Int64 start, Int32 projectedLength, bool assignMap) { Logger.writeLog("Predict-1"); Int64 levelStart = start; Int64 sum = 0; PredictResult predictResult = new PredictResult(); predictResult.estimatedChildCount = 0; Logger.writeLog("Predict-2"); do { Logger.writeLog("Predict-3"); if (start < 0 || start >= asn1Data.RawData.Length || asn1Data.RawData[start] == 0) { Logger.writeLog("Predict-4"); predictResult.result = false; return(predictResult); } Logger.writeLog("Predict-5"); Int64 pl = CalculatePredictLength(asn1Data, start); sum += pl; Logger.writeLog("Predict-6"); if (assignMap && sum <= projectedLength) { Logger.writeLog("Predict-7"); asn1Data.offsetMap[start] = new AsnInternalMap { LevelStart = levelStart, LevelEnd = projectedLength }; } Logger.writeLog("Predict-8"); start += pl; predictResult.estimatedChildCount++; } while (sum < projectedLength); Logger.writeLog("Predict-9"); if (sum != projectedLength) { Logger.writeLog("Predict-10"); predictResult.estimatedChildCount = 0; } Logger.writeLog("Predict-11"); predictResult.result = sum == projectedLength; Logger.writeLog("Predict-12"); return(predictResult); }
static void ParseNestedType(Asn1Data asn1Data) { // 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. if (asn1Data.excludedTags.HasKey(asn1Data.Tag) || asn1Data.PayloadLength < 2) { return; } Int64 pstart = asn1Data.PayloadStartOffset; Int32 plength = asn1Data.PayloadLength; if (asn1Data.Tag == 3) { pstart = asn1Data.PayloadStartOffset + 1; plength = asn1Data.PayloadLength - 1; } if (asn1Data.multiNestedTypes.HasKey(asn1Data.Tag) || (asn1Data.Tag & (Byte)Asn1Class.CONSTRUCTED) > 0) { asn1Data.IsConstructed = true; if (!asn1Data.offsetMap.HasKey(pstart)) { PredictResult predictResult = Predict(asn1Data, pstart, plength, true); asn1Data.childCount = predictResult.estimatedChildCount; } asn1Data.isTaggedConstructed = false; return; } if (asn1Data.Tag > 0 && asn1Data.Tag < (Byte)Asn1Type.TAG_MASK) { PredictResult predictResult = Predict(asn1Data, pstart, plength, false); asn1Data.childCount = predictResult.estimatedChildCount; asn1Data.IsConstructed = predictResult.result; // reiterate again and build map for children if (asn1Data.IsConstructed && !asn1Data.offsetMap.HasKey(pstart)) { PredictResult predictResultOther = Predict(asn1Data, pstart, plength, false); asn1Data.childCount = predictResultOther.estimatedChildCount; } } asn1Data.isTaggedConstructed = false; }
static void MoveAndExpectTypesWithMoveNext(Asn1Data asn1Data, params Byte[] expectedTypes) { if (expectedTypes == null) { throw new ArgumentNullException(nameof(expectedTypes)); } foreach (Byte tag in expectedTypes) { asn1Data.tmpHTable[tag] = true; } if (!MoveNext(asn1Data)) { //throw new InvalidDataException("The data is invalid."); } // if (!asn1Data.tmpHTable.HasKey(asn1Data.Tag)) { // throw new Asn1InvalidTagException(); } }
static void MoveAndExpectTypesWithMoveNext(Asn1Data asn1Data, params Byte[] expectedTypes) { if (expectedTypes == null) { throw new ArgumentNullException(nameof(expectedTypes)); } foreach (Byte tag in expectedTypes) { asn1Data.tmpHTable[tag] = true; } if (!MoveNext(asn1Data)) { Logger.writeLog("ERROR-Data is invalid"); return; } if (!asn1Data.tmpHTable.HasKey(asn1Data.Tag)) { Logger.writeLog("ERROR-Invalid Tag"); } }
static Int64 CalculatePredictLength(Asn1Data asn1Data, Int64 offset) { Logger.writeLog("CalculatePredictLength-1"); if (offset + 1 >= asn1Data.RawData.Length || offset < 0) { Logger.writeLog("CalculatePredictLength-2"); return(Int32.MaxValue); } Logger.writeLog("CalculatePredictLength-3"); if (asn1Data.RawData[offset + 1] < 128) { Logger.writeLog("CalculatePredictLength-4"); return(asn1Data.RawData[offset + 1] + 2); } Logger.writeLog("CalculatePredictLength-5"); Int32 lengthbytes = asn1Data.RawData[offset + 1] - 128; Logger.writeLog("CalculatePredictLength-6"); // max length can be encoded by using 4 bytes. if (lengthbytes > 4) { Logger.writeLog("CalculatePredictLength-7"); return(Int32.MaxValue); } Logger.writeLog("CalculatePredictLength-8"); Int32 ppayloadLength = asn1Data.RawData[offset + 2]; Logger.writeLog("CalculatePredictLength-9"); for (Int64 i = offset + 3; i < offset + 2 + lengthbytes; i++) { Logger.writeLog("CalculatePredictLength-10"); ppayloadLength = (ppayloadLength << 8) | asn1Data.RawData[i]; } Logger.writeLog("CalculatePredictLength-11"); // 2 -- transitional + tag return(ppayloadLength + lengthbytes + 2); }
static Boolean MoveAndExpectTypesWithMoveNextCurrentLevel(Asn1Data asn1Data, params Byte[] expectedTypes) { if (expectedTypes == null) { return(false); } foreach (Byte tag in expectedTypes) { asn1Data.tmpHTable[tag] = true; } if (!MoveNextCurrentLevel(asn1Data)) { return(false); } if (!asn1Data.tmpHTable.HasKey(asn1Data.Tag)) { Logger.writeLog("Not Found Value"); return(false); //throw new Asn1InvalidTagException(); } return(true); }
static void InitMemberDefaultValues(Asn1Data asn1Data) { asn1Data.excludedTags = new Map <byte, bool>(); asn1Data.offsetMap = new Map <Int64, AsnInternalMap>(); asn1Data.multiNestedTypes = new Map <byte, bool>(); asn1Data.tmpHTable = new Map <byte, bool>(); asn1Data.excludedTags[0] = true; asn1Data.excludedTags[1] = true; asn1Data.excludedTags[2] = true; asn1Data.excludedTags[5] = true; asn1Data.excludedTags[6] = true; asn1Data.excludedTags[9] = true; asn1Data.excludedTags[10] = true; asn1Data.excludedTags[13] = true; asn1Data.multiNestedTypes[(Byte)Asn1Type.SEQUENCE] = true; asn1Data.multiNestedTypes[(Byte)((Byte)Asn1Type.SEQUENCE | (Byte)Asn1Class.CONSTRUCTED)] = true; asn1Data.multiNestedTypes[(Byte)Asn1Type.SET] = true; asn1Data.multiNestedTypes[(Byte)((Byte)Asn1Type.SET | (Byte)Asn1Class.CONSTRUCTED)] = true; asn1Data.currentPosition = new AsnInternalMap(); asn1Data.offsetMap[0] = asn1Data.currentPosition; }
static String DecodeUtcTime(Asn1Data asn1Data) { DateTime dt = Asn1UtcTime.Decode(asn); return(dt.ToShortDateString() + " " + dt.ToShortTimeString()); }
public static bool Initialize(Asn1Data asn1Data, Byte[] raw, Int32 pOffset) { asn1Data.IsConstructed = false; if (raw != null) { asn1Data.RawData = raw; } asn1Data.Offset = pOffset; asn1Data.Tag = asn1Data.RawData[asn1Data.Offset]; CalculateLength(asn1Data); // strip possible unnecessary bytes if (raw != null && asn1Data.TagLength != asn1Data.RawData.Length) { asn1Data.RawData = raw.Take(asn1Data.TagLength); } GetTagName(asn1Data, asn1Data.Tag); // 0 Tag is reserved for BER and is not available in DER if (asn1Data.Tag == 0) { Logger.writeLog("ERROR-Invalid tag"); return(false); //throw new Asn1InvalidTagException(asn1Data.Offset); } Logger.writeLog("Initialize-11"); if (asn1Data.PayloadLength == 0) { Logger.writeLog("Initialize-12"); int rawDataLength = asn1Data.RawData.Length; int offsetAndTagLength = asn1Data.Offset + asn1Data.TagLength; if (offsetAndTagLength == rawDataLength) { Logger.writeLog("Initialize-13"); asn1Data.NextOffset = 0; } else { Logger.writeLog("Initialize-14"); asn1Data.NextOffset = offsetAndTagLength; } Logger.writeLog("Initialize-15"); // TODO check this if (asn1Data.currentPosition.LevelEnd == 0 || asn1Data.Offset - asn1Data.currentPosition.LevelStart + asn1Data.TagLength == asn1Data.currentPosition.LevelEnd) { Logger.writeLog("Initialize-16"); asn1Data.NextCurrentLevelOffset = 0; } else { Logger.writeLog("Initialize-17"); asn1Data.NextCurrentLevelOffset = asn1Data.NextOffset; } Logger.writeLog("Initialize-18"); //NextCurrentLevelOffset = NextOffset; return; } Logger.writeLog("Initialize-19"); ParseNestedType(asn1Data); Logger.writeLog("Initialize-20"); if (asn1Data.Offset - asn1Data.currentPosition.LevelStart + asn1Data.TagLength < asn1Data.currentPosition.LevelEnd) { Logger.writeLog("Initialize-21"); asn1Data.NextCurrentLevelOffset = asn1Data.Offset + asn1Data.TagLength; } else { Logger.writeLog("Initialize-21"); asn1Data.NextCurrentLevelOffset = 0; } if (asn1Data.IsConstructed) { Logger.writeLog("Initialize-23"); if (asn1Data.Tag == 3) { Logger.writeLog("Initialize-24"); asn1Data.NextOffset = asn1Data.PayloadStartOffset + 1; } else { Logger.writeLog("Initialize-25"); asn1Data.NextOffset = asn1Data.PayloadStartOffset; } } else { Logger.writeLog("Initialize-26"); if (asn1Data.Offset + asn1Data.TagLength < asn1Data.RawData.Length) { Logger.writeLog("Initialize-27"); asn1Data.NextOffset = asn1Data.Offset + asn1Data.TagLength; } else { Logger.writeLog("Initialize-28"); asn1Data.NextOffset = 0; } } }
static void Init(Asn1Data asn1Data, Asn1GeneralizedTime asn1GeneralizedTime) { asn1GeneralizedTime.Tag = asn1Data.Tag; asn1GeneralizedTime.TagName = asn1Data.TagName; asn1GeneralizedTime.RawData = Asn1Parser.GetTagRawData(asn1Data); }
static Asn1Data Decode(Asn1Data asn1Data, Asn1GeneralizedTime asn1GeneralizedTime) { Init(asn1Data, asn1GeneralizedTime); asn1GeneralizedTime.tagValue = DateTimeUtils.Decode(asn1Data); return(asn1Data); }