public CBORObject GetString(long smallIndex)
{
if (smallIndex < 0)
{
throw new CBORException("Unexpected index");
}
if (smallIndex > Int32.MaxValue)
{
throw new CBORException("Index " + smallIndex +
" is bigger than supported ");
}
var index = (int)smallIndex;
List <CBORObject> lastList = this.stack[this.stack.Count - 1];
if (index >= lastList.Count)
{
throw new CBORException("Index " + index + " is not valid");
}
CBORObject ret = lastList[index];
// Byte strings are mutable, so make a copy
return((ret.Type == CBORType.ByteString) ?
CBORObject.FromObject(ret.GetByteString()) : ret);
}
public CBORObject GetString(EInteger bigIndex)
{
if (bigIndex.Sign < 0)
{
throw new CBORException("Unexpected index");
}
if (!bigIndex.CanFitInInt32())
{
throw new CBORException("Index " + bigIndex +
" is bigger than supported ");
}
var index = (int)bigIndex;
List <CBORObject> lastList = this.stack[this.stack.Count - 1];
if (index >= lastList.Count)
{
throw new CBORException("Index " + index + " is not valid");
}
CBORObject ret = lastList[index];
// Byte strings are mutable, so make a copy
return((ret.Type == CBORType.ByteString) ?
CBORObject.FromObject(ret.GetByteString()) : ret);
}
internal static CBORObject ParseJSONNumber(
string str,
int offset,
int count,
JSONOptions options,
int[] endOfNumber)
{
if (String.IsNullOrEmpty(str) || count <= 0)
{
return(null);
}
if (offset < 0 || offset > str.Length)
{
return(null);
}
if (count > str.Length || str.Length - offset < count)
{
return(null);
}
JSONOptions opt = options ?? DefaultOptions;
bool preserveNegativeZero = options.PreserveNegativeZero;
JSONOptions.ConversionMode kind = options.NumberConversion;
int endPos = offset + count;
int initialOffset = offset;
var negative = false;
if (str[initialOffset] == '-')
{
++offset;
negative = true;
}
int numOffset = offset;
var haveDecimalPoint = false;
var haveDigits = false;
var haveDigitsAfterDecimal = false;
var haveExponent = false;
int i = offset;
var decimalPointPos = -1;
// Check syntax
int k = i;
if (endPos - 1 > k && str[k] == '0' && str[k + 1] >= '0' &&
str[k + 1] <= '9')
{
if (endOfNumber != null)
{
endOfNumber[0] = k + 2;
}
return(null);
}
for (; k < endPos; ++k)
{
char c = str[k];
if (c >= '0' && c <= '9')
{
haveDigits = true;
haveDigitsAfterDecimal |= haveDecimalPoint;
}
else if (c == '.')
{
if (!haveDigits || haveDecimalPoint)
{
// no digits before the decimal point,
// or decimal point already seen
if (endOfNumber != null)
{
endOfNumber[0] = k;
}
return(null);
}
haveDecimalPoint = true;
decimalPointPos = k;
}
else if (c == 'E' || c == 'e')
{
++k;
haveExponent = true;
break;
}
else
{
if (endOfNumber != null)
{
endOfNumber[0] = k;
// Check if character can validly appear after a JSON number
if (c != ',' && c != ']' && c != '}' &&
c != 0x20 && c != 0x0a && c != 0x0d && c != 0x09)
{
return(null);
}
else
{
endPos = k;
break;
}
}
return(null);
}
}
if (!haveDigits || (haveDecimalPoint && !haveDigitsAfterDecimal))
{
if (endOfNumber != null)
{
endOfNumber[0] = k;
}
return(null);
}
var exponentPos = -1;
var negativeExp = false;
if (haveExponent)
{
haveDigits = false;
if (k == endPos)
{
if (endOfNumber != null)
{
endOfNumber[0] = k;
}
return(null);
}
char c = str[k];
if (c == '+')
{
++k;
}
else if (c == '-')
{
negativeExp = true;
++k;
}
for (; k < endPos; ++k)
{
c = str[k];
if (c >= '0' && c <= '9')
{
if (exponentPos < 0 && c != '0')
{
exponentPos = k;
}
haveDigits = true;
}
else if (endOfNumber != null)
{
endOfNumber[0] = k;
// Check if character can validly appear after a JSON number
if (c != ',' && c != ']' && c != '}' &&
c != 0x20 && c != 0x0a && c != 0x0d && c != 0x09)
{
return(null);
}
else
{
endPos = k;
break;
}
}
else
{
return(null);
}
}
if (!haveDigits)
{
if (endOfNumber != null)
{
endOfNumber[0] = k;
}
return(null);
}
}
if (endOfNumber != null)
{
endOfNumber[0] = endPos;
}
if (exponentPos >= 0 && endPos - exponentPos > 20)
{
// Exponent too high for precision to overcome (which
// has a length no bigger than Int32.MaxValue, which is 10 digits
// long)
if (negativeExp)
{
// underflow
if (kind == JSONOptions.ConversionMode.Double ||
kind == JSONOptions.ConversionMode.IntOrFloat)
{
if (!negative)
{
return(CBORObject.FromObject((double)0.0));
}
else
{
return(CBORObject.FromFloatingPointBits(0x8000, 2));
}
}
else if (kind ==
JSONOptions.ConversionMode.IntOrFloatFromDouble)
{
return(CBORObject.FromObject(0));
}
}
else
{
// overflow
if (kind == JSONOptions.ConversionMode.Double ||
kind == JSONOptions.ConversionMode.IntOrFloatFromDouble ||
kind == JSONOptions.ConversionMode.IntOrFloat)
{
return(CBORObject.FromObject(
negative ? Double.NegativeInfinity : Double.PositiveInfinity));
}
else if (kind == JSONOptions.ConversionMode.Decimal128)
{
return(CBORObject.FromObject(negative ?
EDecimal.NegativeInfinity : EDecimal.PositiveInfinity));
}
}
}
if (!haveExponent && !haveDecimalPoint &&
(endPos - numOffset) <= 16)
{
// Very common case of all-digit JSON number strings
// less than 2^53 (with or without number sign)
long v = 0L;
int vi = numOffset;
for (; vi < endPos; ++vi)
{
v = (v * 10) + (int)(str[vi] - '0');
}
if ((v != 0 || !negative) && v < (1L << 53) - 1)
{
if (negative)
{
v = -v;
}
if (kind == JSONOptions.ConversionMode.Double)
{
return(CBORObject.FromObject((double)v));
}
else if (kind == JSONOptions.ConversionMode.Decimal128)
{
return(CBORObject.FromObject(EDecimal.FromInt64(v)));
}
else
{
return(CBORObject.FromObject(v));
}
}
}
if (kind == JSONOptions.ConversionMode.Full)
{
if (!haveDecimalPoint && !haveExponent)
{
EInteger ei = EInteger.FromSubstring(str, initialOffset, endPos);
if (preserveNegativeZero && ei.IsZero && negative)
{
// TODO: In next major version, change to EDecimal.NegativeZero
return(CBORObject.FromFloatingPointBits(0x8000, 2));
}
return(CBORObject.FromObject(ei));
}
if (!haveExponent && haveDecimalPoint && (endPos - numOffset) <= 19)
{
// No more than 18 digits plus one decimal point (which
// should fit a long)
long lv = 0L;
int expo = -(endPos - (decimalPointPos + 1));
int vi = numOffset;
for (; vi < decimalPointPos; ++vi)
{
lv = checked ((lv * 10) + (int)(str[vi] - '0'));
}
for (vi = decimalPointPos + 1; vi < endPos; ++vi)
{
lv = checked ((lv * 10) + (int)(str[vi] - '0'));
}
if (negative)
{
lv = -lv;
}
if (!negative || lv != 0)
{
if (expo == 0)
{
return(CBORObject.FromObject(lv));
}
else
{
CBORObject cbor = CBORObject.FromObject(
new CBORObject[] {
CBORObject.FromObject(expo),
CBORObject.FromObject(lv),
});
return(cbor.WithTag(4));
}
}
}
EDecimal ed = EDecimal.FromString(
str,
initialOffset,
endPos - initialOffset);
if (ed.IsZero && negative)
{
if (ed.Exponent.IsZero)
{
// TODO: In next major version, use EDecimal
// for preserveNegativeZero
return(preserveNegativeZero ?
CBORObject.FromFloatingPointBits(0x8000, 2) :
CBORObject.FromObject(0));
}
else if (!preserveNegativeZero)
{
return(CBORObject.FromObject(ed.Negate()));
}
else
{
return(CBORObject.FromObject(ed));
}
}
else
{
return(ed.Exponent.IsZero ? CBORObject.FromObject(ed.Mantissa) :
CBORObject.FromObject(ed));
}
}
else if (kind == JSONOptions.ConversionMode.Double)
{
// TODO: Avoid converting to double
double dbl = EFloat.FromString(
str,
initialOffset,
endPos - initialOffset,
EContext.Binary64).ToDouble();
if (!preserveNegativeZero && dbl == 0.0)
{
dbl = 0.0;
}
return(CBORObject.FromObject(dbl));
}
else if (kind == JSONOptions.ConversionMode.Decimal128)
{
EDecimal ed = EDecimal.FromString(
str,
initialOffset,
endPos - initialOffset,
EContext.Decimal128);
if (!preserveNegativeZero && ed.IsNegative && ed.IsZero)
{
ed = ed.Negate();
}
return(CBORObject.FromObject(ed));
}
else if (kind == JSONOptions.ConversionMode.IntOrFloatFromDouble)
{
// TODO: Avoid converting to double
double dbl = EFloat.FromString(
str,
initialOffset,
endPos - initialOffset,
EContext.Binary64).ToDouble();
if (!Double.IsNaN(dbl) && dbl >= -9007199254740991.0 &&
dbl <= 9007199254740991.0 && Math.Floor(dbl) == dbl)
{
var idbl = (long)dbl;
return(CBORObject.FromObject(idbl));
}
return(CBORObject.FromObject(dbl));
}
else if (kind == JSONOptions.ConversionMode.IntOrFloat)
{
EContext ctx = EContext.Binary64.WithBlankFlags();
// TODO: Avoid converting to double
double dbl = EFloat.FromString(
str,
initialOffset,
endPos - initialOffset,
ctx).ToDouble();
if ((ctx.Flags & EContext.FlagInexact) != 0)
{
// Inexact conversion to double, meaning that the string doesn't
// represent an integer in [-(2^53)+1, 2^53), which is representable
// exactly as double, so treat as ConversionMode.Double
if (!preserveNegativeZero && dbl == 0.0)
{
dbl = 0.0;
}
return(CBORObject.FromObject(dbl));
}
else
{
// Exact conversion; treat as ConversionMode.IntToFloatFromDouble
if (!Double.IsNaN(dbl) && dbl >= -9007199254740991.0 &&
dbl <= 9007199254740991.0 && Math.Floor(dbl) == dbl)
{
var idbl = (long)dbl;
return(CBORObject.FromObject(idbl));
}
return(CBORObject.FromObject(dbl));
}
}
else
{
throw new ArgumentException("Unsupported conversion kind.");
}
}
#pragma warning disable CS3021 // Le type ou le membre n'a pas besoin d'un attribut CLSCompliant, car l'assembly n'a pas d'attribut CLSCompliant
public static CBORObject FromObject(ulong value)
{
#pragma warning restore CS3021 // Le type ou le membre n'a pas besoin d'un attribut CLSCompliant, car l'assembly n'a pas d'attribut CLSCompliant
return(CBORObject.FromObject(UInt64ToEInteger(value)));
}
public CBORObject ReadForFirstByte(int firstbyte)
{
if (this.depth > 500)
{
throw new CBORException("Too deeply nested");
}
if (firstbyte < 0)
{
throw new CBORException("Premature end of data");
}
if (firstbyte == 0xff)
{
throw new CBORException("Unexpected break code encountered");
}
int type = (firstbyte >> 5) & 0x07;
int additional = firstbyte & 0x1f;
long uadditional;
CBORObject fixedObject;
if (this.options.Ctap2Canonical)
{
if (additional >= 0x1c)
{
// NOTE: Includes stop byte and indefinite length data items
throw new CBORException("Invalid canonical CBOR encountered");
}
// Check if this represents a fixed object (NOTE: All fixed objects
// comply with CTAP2 canonical CBOR).
fixedObject = CBORObject.GetFixedObject(firstbyte);
if (fixedObject != null)
{
return(fixedObject);
}
if (type == 6)
{
throw new CBORException("Tags not allowed in canonical CBOR");
}
uadditional = ReadDataLength(
this.stream,
firstbyte,
type,
type == 7);
if (type == 0)
{
return((uadditional >> 63) != 0 ?
CBORObject.FromObject(ToUnsignedEInteger(uadditional)) :
CBORObject.FromObject(uadditional));
}
else if (type == 1)
{
return((uadditional >> 63) != 0 ? CBORObject.FromObject(
ToUnsignedEInteger(uadditional).Add(1).Negate()) :
CBORObject.FromObject((-uadditional) - 1L));
}
else if (type == 7)
{
if (additional < 24)
{
return(CBORObject.FromSimpleValue(additional));
}
else if (additional == 24 && uadditional < 32)
{
throw new CBORException("Invalid simple value encoding");
}
else if (additional == 24)
{
return(CBORObject.FromSimpleValue((int)uadditional));
}
else if (additional == 25)
{
return(CBORObject.FromFloatingPointBits(uadditional, 2));
}
else if (additional == 26)
{
return(CBORObject.FromFloatingPointBits(uadditional, 4));
}
else if (additional == 27)
{
return(CBORObject.FromFloatingPointBits(uadditional, 8));
}
}
else if (type >= 2 && type <= 5)
{
return(this.ReadStringArrayMap(type, uadditional));
}
throw new CBORException("Unexpected data encountered");
}
int expectedLength = CBORObject.GetExpectedLength(firstbyte);
// Data checks
if (expectedLength == -1)
{
// if the head byte is invalid
throw new CBORException("Unexpected data encountered");
}
// Check if this represents a fixed object
fixedObject = CBORObject.GetFixedObject(firstbyte);
if (fixedObject != null)
{
return(fixedObject);
}
// Read fixed-length data
byte[] data = null;
if (expectedLength != 0)
{
data = new byte[expectedLength];
// include the first byte because GetFixedLengthObject
// will assume it exists for some head bytes
data[0] = unchecked ((byte)firstbyte);
if (expectedLength > 1 &&
this.stream.Read(data, 1, expectedLength - 1) != expectedLength
- 1)
{
throw new CBORException("Premature end of data");
}
CBORObject cbor = CBORObject.GetFixedLengthObject(firstbyte, data);
if (this.stringRefs != null && (type == 2 || type == 3))
{
this.stringRefs.AddStringIfNeeded(cbor, expectedLength - 1);
}
return(cbor);
}
if (additional == 31)
{
// Indefinite-length for major types 2 to 5 (other major
// types were already handled in the call to
// GetFixedLengthObject).
switch (type)
{
case 2: {
// Streaming byte string
using (var ms = new MemoryStream()) {
// Requires same type as this one
while (true)
{
int nextByte = this.stream.ReadByte();
if (nextByte == 0xff)
{
// break if the "break" code was read
break;
}
long len = ReadDataLength(this.stream, nextByte, 2);
if ((len >> 63) != 0 || len > Int32.MaxValue)
{
throw new CBORException("Length" + ToUnsignedEInteger(len)
+
" is bigger than supported ");
}
if (nextByte != 0x40)
{
// NOTE: 0x40 means the empty byte string
ReadByteData(this.stream, len, ms);
}
}
if (ms.Position > Int32.MaxValue)
{
throw new
CBORException("Length of bytes to be streamed is bigger" +
"\u0020than supported ");
}
data = ms.ToArray();
return(CBORObject.FromRaw(data));
}
}
case 3: {
// Streaming text string
var builder = new StringBuilder();
while (true)
{
int nextByte = this.stream.ReadByte();
if (nextByte == 0xff)
{
// break if the "break" code was read
break;
}
long len = ReadDataLength(this.stream, nextByte, 3);
if ((len >> 63) != 0 || len > Int32.MaxValue)
{
throw new CBORException("Length" + ToUnsignedEInteger(len) +
" is bigger than supported");
}
if (nextByte != 0x60)
{
// NOTE: 0x60 means the empty string
if (PropertyMap.ExceedsKnownLength(this.stream, len))
{
throw new CBORException("Premature end of data");
}
switch (
DataUtilities.ReadUtf8(
this.stream,
(int)len,
builder,
false))
{
case -1:
throw new CBORException("Invalid UTF-8");
case -2:
throw new CBORException("Premature end of data");
}
}
}
return(CBORObject.FromRaw(builder.ToString()));
}
case 4: {
CBORObject cbor = CBORObject.NewArray();
var vtindex = 0;
// Indefinite-length array
while (true)
{
int headByte = this.stream.ReadByte();
if (headByte < 0)
{
throw new CBORException("Premature end of data");
}
if (headByte == 0xff)
{
// Break code was read
break;
}
++this.depth;
CBORObject o = this.ReadForFirstByte(
headByte);
--this.depth;
cbor.Add(o);
++vtindex;
}
return(cbor);
}
case 5: {
CBORObject cbor = CBORObject.NewMap();
// Indefinite-length map
while (true)
{
int headByte = this.stream.ReadByte();
if (headByte < 0)
{
throw new CBORException("Premature end of data");
}
if (headByte == 0xff)
{
// Break code was read
break;
}
++this.depth;
CBORObject key = this.ReadForFirstByte(headByte);
CBORObject value = this.ReadInternal();
--this.depth;
if (!this.options.AllowDuplicateKeys)
{
if (cbor.ContainsKey(key))
{
throw new CBORException("Duplicate key already exists");
}
}
cbor[key] = value;
}
return(cbor);
}
default: throw new CBORException("Unexpected data encountered");
}
}
EInteger bigintAdditional = EInteger.Zero;
uadditional = ReadDataLength(this.stream, firstbyte, type);
// The following doesn't check for major types 0 and 1,
// since all of them are fixed-length types and are
// handled in the call to GetFixedLengthObject.
if (type >= 2 && type <= 5)
{
return(this.ReadStringArrayMap(type, uadditional));
}
if (type == 6) // Tagged item
{
var haveFirstByte = false;
var newFirstByte = -1;
if (this.options.ResolveReferences && (uadditional >> 32) == 0)
{
// NOTE: HandleItemTag treats only certain tags up to 256 specially
this.HandleItemTag(uadditional);
}
++this.depth;
CBORObject o = haveFirstByte ? this.ReadForFirstByte(
newFirstByte) : this.ReadInternal();
--this.depth;
if ((uadditional >> 63) != 0)
{
return(CBORObject.FromObjectAndTag(o,
ToUnsignedEInteger(uadditional)));
}
if (uadditional < 65536)
{
if (this.options.ResolveReferences)
{
int uaddl = uadditional >= 257 ? 257 : (uadditional < 0 ? 0 :
(int)uadditional);
switch (uaddl)
{
case 256:
// string tag
this.stringRefs.Pop();
break;
case 25:
// stringref tag
if (o.IsTagged || o.Type != CBORType.Integer)
{
throw new CBORException("stringref must be an unsigned" +
"\u0020integer");
}
return(this.stringRefs.GetString(o.AsEIntegerValue()));
}
}
return(CBORObject.FromObjectAndTag(
o,
(int)uadditional));
}
return(CBORObject.FromObjectAndTag(
o,
(EInteger)uadditional));
}
throw new CBORException("Unexpected data encountered");
}