public override DecodedObject<object> decodeAny(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { int bufSize = elementInfo.MaxAvailableLen; if (bufSize == 0) return null; System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024); /*int tagValue = (int)decodedTag.Value; for (int i = 0; i < decodedTag.Size; i++) { anyStream.WriteByte((byte)tagValue); tagValue = tagValue >> 8; }*/ if(bufSize<0) bufSize = 1024; int len = 0; if (bufSize > 0) { byte[] buffer = new byte[bufSize]; int readed = stream.Read(buffer, 0, buffer.Length); while (readed > 0) { anyStream.Write(buffer, 0, readed); len += readed; if (elementInfo.MaxAvailableLen > 0) break; readed = stream.Read(buffer, 0, buffer.Length); } } CoderUtils.checkConstraints(len, elementInfo); return new DecodedObject<object>(anyStream.ToArray(), len); }
public override DecodedObject <object> decodeReal(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real, elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); int realPreamble = stream.ReadByte(); Double result = 0.0D; int szResult = len.Value; if ((realPreamble & 0x40) == 1) { // 01000000 Value is PLUS-INFINITY result = Double.PositiveInfinity; } if ((realPreamble & 0x41) == 1) { // 01000001 Value is MINUS-INFINITY result = Double.NegativeInfinity; szResult += 1; } else if (len.Value > 0) { int szOfExp = 1 + (realPreamble & 0x3); int sign = realPreamble & 0x40; int ff = (realPreamble & 0x0C) >> 2; DecodedObject <object> exponentEncFrm = decodeLongValue(stream, new DecodedObject <int>(szOfExp)); long exponent = (long)exponentEncFrm.Value; DecodedObject <object> mantissaEncFrm = decodeLongValue(stream, new DecodedObject <int>(szResult - szOfExp - 1)); // Unpack mantissa & decrement exponent for base 2 long mantissa = (long)mantissaEncFrm.Value << ff; while ((mantissa & 0x000ff00000000000L) == 0x0) { exponent -= 8; mantissa <<= 8; } while ((mantissa & 0x0010000000000000L) == 0x0) { exponent -= 1; mantissa <<= 1; } mantissa &= 0x0FFFFFFFFFFFFFL; long lValue = (exponent + 1023 + 52) << 52; lValue |= mantissa; if (sign == 1) { lValue = (long)((ulong)lValue | 0x8000000000000000L); } #if PocketPC byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue); result = System.BitConverter.ToDouble(dblValAsBytes, 0); #else result = System.BitConverter.Int64BitsToDouble(lValue); #endif } return(new DecodedObject <object>(result, len.Value + len.Size)); }
public override DecodedObject <object> decodeBitString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { DecodedObject <object> result = new DecodedObject <object>(); skipAlignedBits(stream); int sizeOfString = decodeLength(elementInfo, stream); BitArrayInputStream bitStream = (BitArrayInputStream)stream; skipAlignedBits(stream); int trailBits = 8 - sizeOfString % 8; sizeOfString = sizeOfString / 8; if (sizeOfString > 0 || (sizeOfString == 0 && trailBits > 0)) { byte[] value = new byte[trailBits > 0 ? sizeOfString + 1 : sizeOfString]; if (sizeOfString > 0) { stream.Read(value, 0, sizeOfString); } if (trailBits > 0) { value[sizeOfString] = (byte)(bitStream.readBits(trailBits) << (8 - trailBits)); } result.Value = (new BitString(value, trailBits)); } else { result.Value = (new BitString(new byte[0])); } return(result); }
protected internal int encodeHeader(DecodedObject <int> tagValue, int contentLen, Stream stream) { int resultSize = encodeLength(contentLen, stream); resultSize += encodeTag(tagValue, stream); return(resultSize); }
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!PERCoderUtils.is7BitEncodedString(elementInfo)) return base.decodeString(decodedTag, objectClass, elementInfo, stream); else { DecodedObject<object> result = new DecodedObject<object>(); int strLen = decodeLength(elementInfo, stream); if (strLen <= 0) { result.Value = (""); return result; } BitArrayInputStream bitStream = (BitArrayInputStream) stream; byte[] buffer = new byte[strLen]; // 7-bit decoding of string for (int i = 0; i < strLen; i++) buffer[i] = (byte)bitStream.readBits(7); result.Value = new string( System.Text.ASCIIEncoding.ASCII.GetChars(buffer) ); return result; } }
public override DecodedObject <object> decodeSequenceOf(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { Type paramType = (Type)objectClass.GetGenericArguments()[0]; Type collectionType = typeof(List <>); Type genCollectionType = collectionType.MakeGenericType(paramType); Object param = Activator.CreateInstance(genCollectionType); int countOfElements = decodeLength(elementInfo, stream); MethodInfo method = param.GetType().GetMethod("Add"); for (int i = 0; i < countOfElements; i++) { ElementInfo elementItemInfo = new ElementInfo(); elementItemInfo.ParentAnnotatedClass = elementInfo.AnnotatedClass; elementItemInfo.AnnotatedClass = paramType; if (elementInfo.hasPreparedInfo()) { ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata; elementItemInfo.PreparedInfo = seqOfMeta.getItemClassMetadata(); } else { elementItemInfo.ASN1ElementInfo = null; } DecodedObject <object> item = decodeClassType(null, paramType, elementItemInfo, stream); if (item != null) { method.Invoke(param, new[] { item.Value }); } } return(new DecodedObject <object>(param)); }
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { if (!PERCoderUtils.is7BitEncodedString(elementInfo)) { return(base.decodeString(decodedTag, objectClass, elementInfo, stream)); } else { DecodedObject <object> result = new DecodedObject <object>(); int strLen = decodeLength(elementInfo, stream); if (strLen <= 0) { result.Value = ""; } else { BitArrayInputStream bitStream = (BitArrayInputStream)stream; // 7-bit decoding of string byte[] buffer = new byte[strLen]; for (int i = 0; i < strLen; i++) { buffer[i] = (byte)bitStream.readBits(7); } result.Value = new string(ASCIIEncoding.ASCII.GetChars(buffer)); } return(result); } }
public override DecodedObject <object> decodeBoolean(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { DecodedObject <object> result = new DecodedObject <object>(); BitArrayInputStream bitStream = (BitArrayInputStream)stream; result.Value = (bitStream.readBit() == 1); return(result); }
public override DecodedObject <object> decodeEnumItem(DecodedObject <object> decodedTag, System.Type objectClass, System.Type enumClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Enumerated, elementInfo)) { return(null); } return(decodeIntegerValue(stream)); }
public override DecodedObject <object> decodeReal(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { BitArrayInputStream bitStream = (BitArrayInputStream)stream; int len = decodeLengthDeterminant(bitStream); int realPreamble = stream.ReadByte(); skipAlignedBits(stream); Double result = 0.0D; int szResult = len; if ((realPreamble & 0x40) == 1) { // 01000000 Value is PLUS-INFINITY result = Double.PositiveInfinity; } if ((realPreamble & 0x41) == 1) { // 01000001 Value is MINUS-INFINITY result = Double.NegativeInfinity; szResult += 1; } else if (len > 0) { int szOfExp = 1 + (realPreamble & 0x3); int sign = realPreamble & 0x40; int ff = (realPreamble & 0x0C) >> 2; long exponent = decodeIntegerValueAsBytes(szOfExp, stream); long mantissaEncFrm = decodeIntegerValueAsBytes(szResult - szOfExp - 1, stream); // Unpack mantissa & decrement exponent for base 2 long mantissa = mantissaEncFrm << ff; while ((mantissa & 0x000ff00000000000L) == 0x0) { exponent -= 8; mantissa <<= 8; } while ((mantissa & 0x0010000000000000L) == 0x0) { exponent -= 1; mantissa <<= 1; } mantissa &= 0x0FFFFFFFFFFFFFL; long lValue = (exponent + 1023 + 52) << 52; lValue |= mantissa; if (sign == 1) { lValue = (long)((ulong)lValue | 0x8000000000000000L); } #if PocketPC byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue); result = System.BitConverter.ToDouble(dblValAsBytes, 0); #else result = System.BitConverter.Int64BitsToDouble(lValue); #endif } return(new DecodedObject <object>(result, szResult)); }
protected bool checkTagForObject(DecodedObject <object> decodedTag, int tagClass, int elementType, int universalTag, ElementInfo elementInfo) { if (decodedTag == null) { return(false); } int definedTag = BERCoderUtils.getTagValueForElement(elementInfo, tagClass, elementType, universalTag).Value; return(definedTag == (int)decodedTag.Value); }
public override DecodedObject <object> decodeObjectIdentifier(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { DecodedObject <int> len = BERCoderUtils.decodeLength(stream); byte[] byteBuf = new byte[len.value]; stream.Read(byteBuf, 0, byteBuf.Length); string dottedDecimal = BERObjectIdentifier.Decode(byteBuf); return(new DecodedObject <object>(new ObjectIdentifier(dottedDecimal))); }
public override DecodedObject<object> decodeBitString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring, elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); int trailBitCnt = stream.ReadByte(); CoderUtils.checkConstraints(len.Value * 8 - trailBitCnt, elementInfo); byte[] byteBuf = new byte[len.Value - 1]; stream.Read(byteBuf,0,byteBuf.Length); return new DecodedObject<object>( new BitString(byteBuf,trailBitCnt), len.Value + len.Size); }
public override DecodedObject <object> decodeSequenceOf(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!CoderUtils.isSequenceSetOf(elementInfo)) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo)) { return(null); } } else { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo)) { return(null); } } Type paramType = (System.Type)objectClass.GetGenericArguments()[0]; Type collectionType = typeof(List <>); Type genCollectionType = collectionType.MakeGenericType(paramType); Object param = Activator.CreateInstance(genCollectionType); DecodedObject <int> len = decodeLength(stream); if (len.Value != 0) { int lenOfItems = 0; int itemsCnt = 0; do { ElementInfo info = new ElementInfo(); info.ParentAnnotatedClass = elementInfo.AnnotatedClass; info.AnnotatedClass = paramType; if (elementInfo.hasPreparedInfo()) { ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata; info.PreparedInfo = (seqOfMeta.getItemClassMetadata()); } DecodedObject <object> itemTag = decodeTag(stream); DecodedObject <object> item = decodeClassType(itemTag, paramType, info, stream); MethodInfo method = param.GetType().GetMethod("Add"); if (item != null) { lenOfItems += item.Size + itemTag.Size; method.Invoke(param, new object[] { item.Value }); itemsCnt++; } }while (lenOfItems < len.Value); CoderUtils.checkConstraints(itemsCnt, elementInfo); } return(new DecodedObject <object>(param, len.Value + len.Size)); }
public override DecodedObject <object> decode(IASN1TypesDecoder decoder, DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { IASN1PreparedElementData saveInfo = elementInfo.PreparedInfo; IASN1PreparedElement instance = (IASN1PreparedElement)elementInfo.PreparedInstance; ASN1ElementMetadata saveElemInfo = elementInfo.PreparedASN1ElementInfo; elementInfo.PreparedInfo = (valueFieldMeta); if (saveElemInfo != null) { if (!saveElemInfo.HasTag && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag) { ASN1ElementMetadata elData = new ASN1ElementMetadata( saveElemInfo.Name, saveElemInfo.IsOptional, elementInfo.PreparedASN1ElementInfo.HasTag, elementInfo.PreparedASN1ElementInfo.IsImplicitTag, elementInfo.PreparedASN1ElementInfo.TagClass, elementInfo.PreparedASN1ElementInfo.Tag, saveElemInfo.HasDefaultValue ); elementInfo.PreparedASN1ElementInfo = elData; } else { elementInfo.PreparedASN1ElementInfo = (saveElemInfo); } } DecodedObject <object> decodedResult = valueFieldMeta.TypeMetadata.decode(decoder, decodedTag, valueField.PropertyType, elementInfo, stream); if (decodedResult != null) { if (!CoderUtils.isNullField(valueField, elementInfo)) { decoder.invokeSetterMethodForField(valueField, instance, decodedResult.Value, elementInfo); } } elementInfo.PreparedInfo = (saveInfo); elementInfo.PreparedInstance = (instance); elementInfo.PreparedASN1ElementInfo = (saveElemInfo); if (decodedResult != null) { return(new DecodedObject <object>(instance, decodedResult.Size)); } else { return(decodedResult); } }
public override DecodedObject<object> decodeBoolean(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Boolean, elementInfo)) return null; DecodedObject<object> result = decodeIntegerValue(stream); int val = (int) result.Value; if (val != 0) result.Value = true; else result.Value = false; return result; }
public override DecodedObject <object> decodeSequence(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { BitArrayInputStream bitStream = (BitArrayInputStream)stream; int preambleLen = getSequencePreambleBitLen(objectClass, elementInfo); int preamble = bitStream.readBits(preambleLen); int preambleCurrentBit = 32 - preambleLen; skipAlignedBits(stream); object sequence = createInstanceForElement(objectClass, elementInfo); initDefaultValues(sequence); ElementInfo info = new ElementInfo(); int idx = 0; PropertyInfo[] fields = null; if (!CoderUtils.isSequenceSet(elementInfo) || elementInfo.hasPreparedInfo()) { fields = elementInfo.getProperties(objectClass); } else { SortedList <int, PropertyInfo> fieldOrder = CoderUtils.getSetOrder(sequence.GetType()); fields = new PropertyInfo[fieldOrder.Values.Count]; fieldOrder.Values.CopyTo(fields, 0); } foreach (PropertyInfo field in fields) { if (elementInfo.hasPreparedInfo()) { info.PreparedInfo = elementInfo.PreparedInfo.getPropertyMetadata(idx); } if (CoderUtils.isOptionalField(field, info)) { if ((preamble & (0x80000000 >> preambleCurrentBit)) != 0) { decodeSequenceField(null, sequence, idx, field, stream, elementInfo, true); } preambleCurrentBit++; } else { decodeSequenceField(null, sequence, idx, field, stream, elementInfo, true); } idx++; } return(new DecodedObject <object>(sequence)); /* } * else * return decodeSet(decodedTag, objectClass, elementInfo, stream);*/ }
public override DecodedObject <object> decodeNull(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Null, elementInfo)) { return(null); } stream.ReadByte(); // ignore null length object obj = createInstanceForElement(objectClass, elementInfo); DecodedObject <object> result = new DecodedObject <object>(obj, 1); return(result); }
public override DecodedObject <object> decodeOctetString(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.OctetString, elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); CoderUtils.checkConstraints(len.Value, elementInfo); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); return(new DecodedObject <object>(byteBuf, len.Value + len.Size)); }
public override DecodedObject <object> decodeBitString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring, elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); int trailBitCnt = stream.ReadByte(); CoderUtils.checkConstraints(len.Value * 8 - trailBitCnt, elementInfo); byte[] byteBuf = new byte[len.Value - 1]; stream.Read(byteBuf, 0, byteBuf.Length); return(new DecodedObject <object>(new BitString(byteBuf, trailBitCnt), len.Value + len.Size)); }
public override DecodedObject <object> decodeObjectIdentifier(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.ObjectIdentifier, elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); string dottedDecimal = BERObjectIdentifier.Decode(byteBuf); return(new DecodedObject <object>(new ObjectIdentifier(dottedDecimal))); }
public static DecodedObject <int> getTagValueForElement(ElementInfo info, int tagClass, int elemenType, int universalTag) { DecodedObject <int> result = new DecodedObject <int>(); // result.Value = tagClass | elemenType | universalTag; if (universalTag < UniversalTags.LastUniversal) { result.Value = tagClass | elemenType | universalTag; } else { result = getTagValue(tagClass, elemenType, universalTag, universalTag, tagClass); } result.Size = 1; if (info.hasPreparedInfo()) { ASN1ElementMetadata meta = info.PreparedASN1ElementInfo; if (meta != null && meta.HasTag) { result = getTagValue(tagClass, elemenType, universalTag, meta.Tag, meta.TagClass ); } } else { ASN1Element elementInfo = null; if (info.ASN1ElementInfo != null) { elementInfo = info.ASN1ElementInfo; } else if (info.isAttributePresent <ASN1Element>()) { elementInfo = info.getAttribute <ASN1Element>(); } if (elementInfo != null) { if (elementInfo.HasTag) { result = getTagValue(tagClass, elemenType, universalTag, elementInfo.Tag, elementInfo.TagClass); } } } return(result); }
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo), elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); CoderUtils.checkConstraints(len.Value, elementInfo); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); string result = CoderUtils.bufferToASN1String(byteBuf, elementInfo); return(new DecodedObject <object>(result, len.Value + len.Size)); }
public static DecodedObject<int> getTagValueForElement(ElementInfo info, int tagClass, int elemenType, int universalTag) { DecodedObject<int> result = new DecodedObject<int>(); // result.Value = tagClass | elemenType | universalTag; if (universalTag < UniversalTags.LastUniversal) { result.Value = tagClass | elemenType | universalTag; } else result = getTagValue(tagClass, elemenType, universalTag, universalTag, tagClass); result.Size = 1; if (info.hasPreparedInfo()) { ASN1ElementMetadata meta = info.PreparedASN1ElementInfo; if (meta != null && meta.HasTag) { result = getTagValue(tagClass, elemenType, universalTag, meta.Tag, meta.TagClass ); } } else { ASN1Element elementInfo = null; if (info.ASN1ElementInfo != null) { elementInfo = info.ASN1ElementInfo; } else if (info.isAttributePresent<ASN1Element>()) { elementInfo = info.getAttribute<ASN1Element>(); } if (elementInfo != null) { if (elementInfo.HasTag) { result = getTagValue(tagClass, elemenType, universalTag, elementInfo.Tag, elementInfo.TagClass); } } } return result; }
public override DecodedObject <object> decodeSequence(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { bool isSet = false; if (!CoderUtils.isSequenceSet(elementInfo)) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo)) { return(null); } } else { if (checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo)) { isSet = true; } else { return(null); } } DecodedObject <int> len = decodeLength(stream); int saveMaxAvailableLen = elementInfo.MaxAvailableLen; elementInfo.MaxAvailableLen = (len.Value); DecodedObject <object> result = null; if (!isSet) { result = base.decodeSequence(decodedTag, objectClass, elementInfo, stream); } else { result = decodeSet(decodedTag, objectClass, elementInfo, len.Value, stream); } if (result.Size != len.Value) { throw new System.ArgumentException("Sequence '" + objectClass.ToString() + "' size is incorrect!"); } result.Size = result.Size + len.Size; elementInfo.MaxAvailableLen = (saveMaxAvailableLen); return(result); }
public override DecodedObject <object> decodeOctetString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { DecodedObject <object> result = new DecodedObject <object>(); int sizeOfString = decodeLength(elementInfo, stream); skipAlignedBits(stream); if (sizeOfString > 0) { byte[] val = new byte[sizeOfString]; stream.Read(val, 0, val.Length); result.Value = val; } else { result.Value = (new byte[0]); } return(result); }
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { DecodedObject <object> result = new DecodedObject <object>(); int strLen = decodeLength(elementInfo, stream); skipAlignedBits(stream); if (strLen > 0) { byte[] val = new byte[strLen]; stream.Read(val, 0, val.Length); result.Value = CoderUtils.bufferToASN1String(val, elementInfo); } else { result.Value = (""); } return(result); }
public override DecodedObject <object> decodeInteger(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer, elementInfo)) { return(null); } if (objectClass.Equals(typeof(int))) { DecodedObject <object> result = decodeIntegerValue(stream); CoderUtils.checkConstraints((int)result.Value, elementInfo); return(result); } else { DecodedObject <object> result = decodeLongValue(stream); CoderUtils.checkConstraints((long)result.Value, elementInfo); return(result); } }
public override DecodedObject <object> decodeBoolean(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Boolean, elementInfo)) { return(null); } DecodedObject <object> result = decodeIntegerValue(stream); int val = (int)result.Value; if (val != 0) { result.Value = true; } else { result.Value = false; } return(result); }
public override DecodedObject <object> decodeChoice(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { object choice = createInstanceForElement(objectClass, elementInfo); skipAlignedBits(stream); PropertyInfo[] fields = elementInfo.getProperties(objectClass); int elementIndex = (int)decodeConstraintNumber(1, fields.Length, (BitArrayInputStream)stream); DecodedObject <object> val = null; for (int i = 0; i < elementIndex && i < fields.Length; i++) { if (i + 1 == elementIndex) { PropertyInfo field = fields[i]; ElementInfo info = new ElementInfo(); info.AnnotatedClass = field; if (elementInfo.hasPreparedInfo()) { info.PreparedInfo = elementInfo.PreparedInfo.getPropertyMetadata(i); } else { info.ASN1ElementInfo = CoderUtils.getAttribute <ASN1Element>(field); } val = decodeClassType(decodedTag, field.PropertyType, info, stream); if (val != null) { invokeSelectMethodForField(field, choice, val.Value, info); } break; } ; } if (val == null && !CoderUtils.isOptional(elementInfo)) { throw new ArgumentException("The choice '" + objectClass + "' does not have a selected item!"); } else { return(new DecodedObject <object>(choice)); } }
public override DecodedObject <object> decodeChoice(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if ((elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag) || (elementInfo.ASN1ElementInfo != null && elementInfo.ASN1ElementInfo.HasTag)) { if (!checkTagForObject(decodedTag, TagClasses.ContextSpecific, ElementType.Constructed, UniversalTags.LastUniversal, elementInfo)) { return(null); } DecodedObject <int> len = decodeLength(stream); DecodedObject <object> childDecodedTag = decodeTag(stream); DecodedObject <object> result = base.decodeChoice(childDecodedTag, objectClass, elementInfo, stream); result.Size += len.Size + childDecodedTag.Size; return(result); } else { return(base.decodeChoice(decodedTag, objectClass, elementInfo, stream)); } }
public static DecodedObject <int> getTagValue(int tagClass, int elemenType, int universalTag, int userTag, int userTagClass) { DecodedObject <int> resultObj = new DecodedObject <int>(); int result = tagClass | elemenType | universalTag; tagClass = userTagClass; if (userTag < 31) { result = tagClass | elemenType | userTag; resultObj.Size = 1; } else { result = tagClass | elemenType | 0x1F; if (userTag < 0x80) { result <<= 8; result |= userTag & 0x7F; resultObj.Size = 2; } else if (userTag < 0x3FFF) { result <<= 16; result |= (((userTag & 0x3FFF) >> 7) | 0x80) << 8; result |= ((userTag & 0x3FFF) & 0x7f); resultObj.Size = 3; } else if (userTag < 0x3FFFF) { result <<= 24; result |= (((userTag & 0x3FFFF) >> 15) | 0x80) << 16; result |= (((userTag & 0x3FFFF) >> 7) | 0x80) << 8; result |= ((userTag & 0x3FFFF) & 0x3f); resultObj.Size = 4; } } resultObj.Value = result; return(resultObj); }
public override DecodedObject <object> decodeInteger(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { bool hasConstraint = false; long min = 0, max = 0; if (elementInfo.hasPreparedInfo()) { if (elementInfo.PreparedInfo.hasConstraint() && elementInfo.PreparedInfo.Constraint is ASN1ValueRangeConstraintMetadata) { IASN1ConstraintMetadata constraint = elementInfo.PreparedInfo.Constraint; hasConstraint = true; min = ((ASN1ValueRangeConstraintMetadata)constraint).Min; max = ((ASN1ValueRangeConstraintMetadata)constraint).Max; } } else if (elementInfo.isAttributePresent <ASN1ValueRangeConstraint>()) { hasConstraint = true; ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>(); min = constraint.Min; max = constraint.Max; } DecodedObject <object> result = new DecodedObject <object>(); BitArrayInputStream bitStream = (BitArrayInputStream)stream; int val = 0; if (hasConstraint) { ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>(); val = (int)decodeConstraintNumber(min, max, bitStream); } else { val = decodeUnconstraintNumber(bitStream); } result.Value = val; return(result); }
public override DecodedObject <object> decodeAny(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { int bufSize = elementInfo.MaxAvailableLen; if (bufSize == 0) { return(null); } System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024); /*int tagValue = (int)decodedTag.Value; * for (int i = 0; i < decodedTag.Size; i++) * { * anyStream.WriteByte((byte)tagValue); * tagValue = tagValue >> 8; * }*/ if (bufSize < 0) { bufSize = 1024; } int len = 0; if (bufSize > 0) { byte[] buffer = new byte[bufSize]; int readed = stream.Read(buffer, 0, buffer.Length); while (readed > 0) { anyStream.Write(buffer, 0, readed); len += readed; if (elementInfo.MaxAvailableLen > 0) { break; } readed = stream.Read(buffer, 0, buffer.Length); } } CoderUtils.checkConstraints(len, elementInfo); return(new DecodedObject <object>(anyStream.ToArray(), len)); }
protected internal int encodeTag(DecodedObject <int> tagValue, Stream stream) { int resultSize = tagValue.Size; int value = tagValue.Value; for (int i = 0; i < tagValue.Size; i++) { stream.WriteByte((byte)value); value = value >> 8; } return(resultSize); /*int resultSize = 0; * if (tagValue.Size == 1) * { * stream.WriteByte((byte)tagValue.Value); * resultSize++; * } * else * resultSize += encodeIntegerValue(tagValue.Value, stream); * return resultSize;*/ }
public abstract DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream);
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo), elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); CoderUtils.checkConstraints(len.Value, elementInfo); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); string result = CoderUtils.bufferToASN1String(byteBuf, elementInfo); return new DecodedObject<object>(result, len.Value + len.Size); }
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { IASN1PreparedElementData saveInfo = elementInfo.PreparedInfo; IASN1PreparedElement instance = (IASN1PreparedElement)elementInfo.PreparedInstance; ASN1ElementMetadata saveElemInfo = elementInfo.PreparedASN1ElementInfo; elementInfo.PreparedInfo = (valueFieldMeta); if (saveElemInfo != null) { if (!saveElemInfo.HasTag && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag) { ASN1ElementMetadata elData = new ASN1ElementMetadata( saveElemInfo.Name, saveElemInfo.IsOptional, elementInfo.PreparedASN1ElementInfo.HasTag, elementInfo.PreparedASN1ElementInfo.IsImplicitTag, elementInfo.PreparedASN1ElementInfo.TagClass, elementInfo.PreparedASN1ElementInfo.Tag, saveElemInfo.HasDefaultValue ); elementInfo.PreparedASN1ElementInfo = elData; } else elementInfo.PreparedASN1ElementInfo = (saveElemInfo); } DecodedObject<object> decodedResult = valueFieldMeta.TypeMetadata.decode(decoder, decodedTag, valueField.PropertyType, elementInfo, stream); if (decodedResult != null) { if (!CoderUtils.isNullField(valueField, elementInfo)) { decoder.invokeSetterMethodForField(valueField, instance, decodedResult.Value, elementInfo); } } elementInfo.PreparedInfo = (saveInfo); elementInfo.PreparedInstance = (instance); elementInfo.PreparedASN1ElementInfo = (saveElemInfo); if (decodedResult != null) return new DecodedObject<object>(instance, decodedResult.Size); else return decodedResult; }
public override DecodedObject<object> decodeInteger(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer, elementInfo)) return null; if (objectClass.Equals(typeof(int))) { DecodedObject<object> result = decodeIntegerValue(stream); CoderUtils.checkConstraints((int)result.Value, elementInfo); return result; } else { DecodedObject<object> result = decodeLongValue(stream); CoderUtils.checkConstraints((long)result.Value, elementInfo); return result; } }
protected internal virtual DecodedObject<object> decodeLongValue(System.IO.Stream stream, DecodedObject<int> len) { DecodedObject<object> result = new DecodedObject<object>(); long val = 0; for (int i = 0; i < len.Value; i++) { long bt = stream.ReadByte(); if (bt == -1) { throw new System.ArgumentException("Unexpected EOF when encoding!"); } if (i == 0 && (bt & (byte)0x80) != 0) { bt = bt - 256; } val = (val << 8) | bt; } result.Value = val; result.Size = len.Value + len.Size; return result; }
public override DecodedObject<object> decodeObjectIdentifier(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.ObjectIdentifier, elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); string dottedDecimal = BERObjectIdentifier.Decode(byteBuf); return new DecodedObject<object>(new ObjectIdentifier(dottedDecimal)); }
public override DecodedObject<object> decodeSequenceOf(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!CoderUtils.isSequenceSetOf(elementInfo)) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo)) return null; } else { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo)) return null; } Type paramType = (System.Type)objectClass.GetGenericArguments()[0]; Type collectionType = typeof(List<>); Type genCollectionType = collectionType.MakeGenericType(paramType); Object param = Activator.CreateInstance(genCollectionType); DecodedObject<int> len = decodeLength(stream); if (len.Value != 0) { int lenOfItems = 0; int itemsCnt = 0; do { ElementInfo info = new ElementInfo(); info.ParentAnnotatedClass = elementInfo.AnnotatedClass; info.AnnotatedClass = paramType; if (elementInfo.hasPreparedInfo()) { ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata; info.PreparedInfo = (seqOfMeta.getItemClassMetadata()); } DecodedObject<object> itemTag = decodeTag(stream); DecodedObject<object> item = decodeClassType(itemTag, paramType, info, stream); MethodInfo method = param.GetType().GetMethod("Add"); if (item != null) { lenOfItems += item.Size + itemTag.Size; method.Invoke(param, new object[] { item.Value }); itemsCnt++; } } while (lenOfItems < len.Value); CoderUtils.checkConstraints(itemsCnt, elementInfo); } return new DecodedObject<object>(param, len.Value + len.Size); }
protected bool checkTagForObject(DecodedObject<object> decodedTag, int tagClass, int elementType, int universalTag, ElementInfo elementInfo) { if (decodedTag == null) return false; int definedTag = BERCoderUtils.getTagValueForElement(elementInfo, tagClass, elementType, universalTag).Value; return definedTag == (int)decodedTag.Value; }
public override DecodedObject<object> decodeEnumItem(DecodedObject<object> decodedTag, System.Type objectClass, System.Type enumClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Enumerated, elementInfo)) return null; return decodeIntegerValue(stream); }
protected virtual DecodedObject<object> decodeSet(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, int len, System.IO.Stream stream) { object sequence = createInstanceForElement(objectClass,elementInfo); initDefaultValues(sequence); DecodedObject<object> fieldTag = null; int sizeOfSequence = 0; int maxSeqLen = elementInfo.MaxAvailableLen; if (maxSeqLen == -1 || maxSeqLen > 0) { fieldTag = decodeTag(stream); if (fieldTag != null) sizeOfSequence += fieldTag.Size; } PropertyInfo[] fields = elementInfo.getProperties(objectClass); bool fieldEncoded = false; do { for (int i = 0; i < fields.Length; i++) { PropertyInfo field = fields[i]; DecodedObject<object> obj = decodeSequenceField( fieldTag, sequence, i, field, stream, elementInfo, false ); if (obj != null) { fieldEncoded = true; sizeOfSequence += obj.Size; bool isAny = false; if (i + 1 == fields.Length - 1) { ElementInfo info = new ElementInfo(); info.AnnotatedClass = (fields[i + 1]); info.MaxAvailableLen = (elementInfo.MaxAvailableLen); if (elementInfo.hasPreparedInfo()) { info.PreparedInfo = (elementInfo.PreparedInfo.getPropertyMetadata(i + 1)); } else info.ASN1ElementInfo = CoderUtils.getAttribute<ASN1Element>(fields[i + 1]); isAny = CoderUtils.isAnyField(fields[i + 1], info); } if (maxSeqLen != -1) { elementInfo.MaxAvailableLen = (maxSeqLen - sizeOfSequence); } if (!isAny) { if (i < fields.Length - 1) { if (maxSeqLen == -1 || elementInfo.MaxAvailableLen > 0) { fieldTag = decodeTag(stream); if (fieldTag != null) sizeOfSequence += fieldTag.Size; else { break; } } else fieldTag = null; } else break; } } ; } } while (sizeOfSequence < len && fieldEncoded); return new DecodedObject<object>(sequence, sizeOfSequence); }
protected DecodedObject<object> decodeIntegerValue(System.IO.Stream stream) { DecodedObject<object> result = new DecodedObject<object>(); DecodedObject<int> len = decodeLength(stream); int val = 0; for (int i = 0; i < len.Value; i++) { int bt = stream.ReadByte(); if (bt == -1) { throw new System.ArgumentException("Unexpected EOF when encoding!"); } if (i == 0 && (bt & (byte)0x80) != 0) { bt = bt - 256; } val = (val << 8) | bt; } result.Value = val; result.Size = len.Value + len.Size; return result; }
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { elementInfo.PreparedInstance = null; return decoder.decodeElement(decodedTag, objectClass, elementInfo, stream); }
public static DecodedObject<int> getTagValue(int tagClass, int elemenType, int universalTag, int userTag, int userTagClass) { DecodedObject<int> resultObj = new DecodedObject<int>(); int result = tagClass | elemenType | universalTag; tagClass = userTagClass; if (userTag < 31) { result = tagClass | elemenType | userTag; resultObj.Size = 1; } else { result = tagClass | elemenType | 0x1F; if (userTag < 0x80) { result <<= 8; result |= userTag & 0x7F; resultObj.Size = 2; } else if (userTag < 0x3FFF) { result <<= 16; result |= (((userTag & 0x3FFF) >> 7) | 0x80) << 8; result |= ((userTag & 0x3FFF) & 0x7f); resultObj.Size = 3; } else if (userTag < 0x3FFFF) { result <<= 24; result |= (((userTag & 0x3FFFF) >> 15) | 0x80) << 16; result |= (((userTag & 0x3FFFF) >> 7) | 0x80) << 8; result |= ((userTag & 0x3FFFF) & 0x3f); resultObj.Size = 4; } } resultObj.Value = result; return resultObj; }
public override DecodedObject<object> decodeOctetString(DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.OctetString, elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); CoderUtils.checkConstraints(len.Value, elementInfo); byte[] byteBuf = new byte[len.Value]; stream.Read(byteBuf, 0, byteBuf.Length); return new DecodedObject<object>(byteBuf, len.Value + len.Size); }
public override DecodedObject<object> decodeChoice(DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if ( (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag) || (elementInfo.ASN1ElementInfo != null && elementInfo.ASN1ElementInfo.HasTag)) { if (!checkTagForObject(decodedTag, TagClasses.ContextSpecific, ElementType.Constructed, UniversalTags.LastUniversal, elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); DecodedObject<object> childDecodedTag = decodeTag(stream); DecodedObject<object> result = base.decodeChoice(childDecodedTag, objectClass, elementInfo, stream); result.Size += len.Size + childDecodedTag.Size; return result; } else return base.decodeChoice(decodedTag, objectClass, elementInfo, stream); }
public override DecodedObject<object> decodeReal(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real, elementInfo)) return null; DecodedObject<int> len = decodeLength(stream); int realPreamble = stream.ReadByte(); Double result = 0.0D; int szResult = len.Value; if ((realPreamble & 0x40) == 1) { // 01000000 Value is PLUS-INFINITY result = Double.PositiveInfinity; } if ((realPreamble & 0x41) == 1) { // 01000001 Value is MINUS-INFINITY result = Double.NegativeInfinity; szResult += 1; } else if (len.Value > 0) { int szOfExp = 1 + (realPreamble & 0x3); int sign = realPreamble & 0x40; int ff = (realPreamble & 0x0C) >> 2; DecodedObject<object> exponentEncFrm = decodeLongValue(stream, new DecodedObject<int>(szOfExp)); long exponent = (long)exponentEncFrm.Value; DecodedObject<object> mantissaEncFrm = decodeLongValue(stream, new DecodedObject<int>(szResult - szOfExp - 1)); // Unpack mantissa & decrement exponent for base 2 long mantissa = (long)mantissaEncFrm.Value << ff; while ((mantissa & 0x000ff00000000000L) == 0x0) { exponent -= 8; mantissa <<= 8; } while ((mantissa & 0x0010000000000000L) == 0x0) { exponent -= 1; mantissa <<= 1; } mantissa &= 0x0FFFFFFFFFFFFFL; long lValue = (exponent + 1023 + 52) << 52; lValue |= mantissa; if (sign == 1) { lValue = (long)((ulong)lValue | 0x8000000000000000L); } #if PocketPC byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue); result = System.BitConverter.ToDouble(dblValAsBytes, 0); #else result = System.BitConverter.Int64BitsToDouble(lValue); #endif } return new DecodedObject<object>(result, len.Value + len.Size); }
public override DecodedObject<object> decodeNull(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Null, elementInfo)) return null; stream.ReadByte(); // ignore null length object obj = createInstanceForElement(objectClass, elementInfo); DecodedObject<object> result = new DecodedObject<object>(obj, 1); return result; }
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream) { return decoder.decodeSequence(decodedTag,objectClass,elementInfo,stream); }
public override DecodedObject<object> decodeSequence(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { bool isSet = false; if (!CoderUtils.isSequenceSet(elementInfo)) { if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo)) { return null; } } else { if (checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo)) { isSet = true; } else return null; } DecodedObject<int> len = decodeLength(stream); int saveMaxAvailableLen = elementInfo.MaxAvailableLen; elementInfo.MaxAvailableLen = (len.Value); DecodedObject<object> result = null; if(!isSet) result =base.decodeSequence(decodedTag, objectClass, elementInfo, stream); else result = decodeSet(decodedTag, objectClass, elementInfo, len.Value, stream); if (result.Size != len.Value) throw new System.ArgumentException("Sequence '" + objectClass.ToString() + "' size is incorrect!"); result.Size = result.Size + len.Size; elementInfo.MaxAvailableLen = (saveMaxAvailableLen); return result; }