public void DecodeSign1_IncorrectStructure()
{
var writer = new CborWriter();
writer.WriteStartArray(4);
writer.WriteNull();
writer.WriteNull();
writer.WriteNull();
writer.WriteNull();
writer.WriteEndArray();
Assert.Throws <CryptographicException>(() => CoseMessage.DecodeSign1(writer.Encode()));
}
public static void WriteNull_SingleValue_HappyPath()
{
byte[] expectedEncoding = "f6".HexToByteArray();
using var writer = new CborWriter();
writer.WriteNull();
AssertHelper.HexEqual(expectedEncoding, writer.GetEncoding());
}
public void SetEncodedValue_KnownHeaders_ThrowIf_IncorrectValue(SetValueMethod method)
{
if (method == SetValueMethod.AddShortcut)
{
return;
}
var writer = new CborWriter();
writer.WriteNull();
byte[] encodedNullValue = writer.Encode();
var map = new CoseHeaderMap();
// only accepts int or tstr
Assert.Throws <ArgumentException>("value", () => SetEncodedValue(map, CoseHeaderLabel.Algorithm, encodedNullValue, method));
// [ +label ] (non-empty array)
Assert.Throws <ArgumentException>("value", () => SetEncodedValue(map, CoseHeaderLabel.CriticalHeaders, encodedNullValue, method));
writer.Reset();
writer.WriteStartArray(0);
writer.WriteEndArray();
Assert.Throws <ArgumentException>("value", () => SetEncodedValue(map, CoseHeaderLabel.CriticalHeaders, writer.Encode(), method));
// tstr / uint
Assert.Throws <ArgumentException>("value", () => SetEncodedValue(map, CoseHeaderLabel.ContentType, encodedNullValue, method));
// bstr
Assert.Throws <ArgumentException>("value", () => SetEncodedValue(map, CoseHeaderLabel.KeyIdentifier, encodedNullValue, method));
}
public static void WriteObject(this CborWriter writer, CborObject @object)
{
if (@object is CborTextString text)
{
writer.WriteTextString(text.Value);
}
else if (@object is CborByteString data)
{
writer.WriteByteString(data.Value);
}
else if (@object is CborBoolean boolean)
{
writer.WriteBoolean(boolean.Value);
}
else if (@object is CborInteger number)
{
writer.WriteInt64(number.Value);
}
else if (@object is CborMap map)
{
writer.WriteMap(map);
}
else if (@object is CborArray array)
{
writer.WriteArray(array);
}
else if (@object.Type == CborType.Null)
{
writer.WriteNull();
}
else
{
throw new Exception($"Unknown type. Was {@object.Type}");
}
}
public static void WriteValue(CborWriter writer, object value, bool useDefiniteLengthCollections = true)
{
switch (value)
{
case null: writer.WriteNull(); break;
case bool b: writer.WriteBoolean(b); break;
case int i: writer.WriteInt32(i); break;
case long i: writer.WriteInt64(i); break;
case ulong i: writer.WriteUInt64(i); break;
case float f: writer.WriteSingle(f); break;
case double d: writer.WriteDouble(d); break;
case decimal d: writer.WriteDecimal(d); break;
case string s: writer.WriteTextString(s); break;
case BigInteger i: writer.WriteBigInteger(i); break;
case DateTimeOffset d: writer.WriteDateTimeOffset(d); break;
case byte[] b: writer.WriteByteString(b); break;
case byte[][] chunks: WriteChunkedByteString(writer, chunks); break;
case string[] chunks when IsIndefiniteLengthByteString(chunks):
byte[][] byteChunks = chunks.Skip(1).Select(ch => ch.HexToByteArray()).ToArray();
WriteChunkedByteString(writer, byteChunks);
break;
case string[] chunks: WriteChunkedTextString(writer, chunks); break;
case object[] nested when IsCborMapRepresentation(nested): WriteMap(writer, nested, useDefiniteLengthCollections); break;
case object[] nested when IsEncodedValueRepresentation(nested):
byte[] encodedValue = ((string)nested[1]).HexToByteArray();
writer.WriteEncodedValue(encodedValue);
break;
case object[] nested when IsTaggedValueRepresentation(nested):
writer.WriteTag((CborTag)nested[0]);
WriteValue(writer, nested[1]);
break;
case object[] nested: WriteArray(writer, nested, useDefiniteLengthCollections); break;
default: throw new ArgumentException($"Unrecognized argument type {value.GetType()}");
}
;
}
void ICborConverter <CborArray?> .Write(ref CborWriter writer, CborArray?value)
{
if (value == null)
{
writer.WriteNull();
return;
}
Write(ref writer, value, LengthMode.Default);
}
public override void Write(ref CborWriter writer, CborValue value, LengthMode lengthMode)
{
switch (value.Type)
{
case CborValueType.Object:
((ICborConverter <CborObject>) this).Write(ref writer, (CborObject)value, lengthMode);
break;
case CborValueType.Array:
((ICborConverter <CborArray>) this).Write(ref writer, (CborArray)value, lengthMode);
break;
case CborValueType.Positive:
writer.WriteUInt64(value.Value <ulong>());
break;
case CborValueType.Negative:
writer.WriteInt64(value.Value <long>());
break;
case CborValueType.Single:
writer.WriteSingle(value.Value <float>());
break;
case CborValueType.Double:
writer.WriteDouble(value.Value <double>());
break;
case CborValueType.Decimal:
writer.WriteDecimal(value.Value <decimal>());
break;
case CborValueType.String:
writer.WriteString(value.Value <string>());
break;
case CborValueType.Boolean:
writer.WriteBoolean(value.Value <bool>());
break;
case CborValueType.Null:
writer.WriteNull();
break;
case CborValueType.ByteString:
writer.WriteByteString(value.Value <ReadOnlyMemory <byte> >().Span);
break;
}
}
public static IEnumerable <object[]> GetValueAsThrowsTestData()
{
// null
var writer = new CborWriter();
writer.WriteNull();
byte[] encodedNull = writer.Encode();
yield return(new object[] { encodedNull, GetValueAs.Int32 });
yield return(new object[] { encodedNull, GetValueAs.String });
yield return(new object[] { encodedNull, GetValueAs.Bytes });
yield return(new object[] { encodedNull, GetValueAs.BytesSpan });
}
public override void Write(ref CborWriter writer, TI[]?value, LengthMode lengthMode)
{
if (value == null)
{
writer.WriteNull();
return;
}
WriterContext context = new WriterContext
{
array = value,
lengthMode = lengthMode != LengthMode.Default
? lengthMode : _options.ArrayLengthMode
};
writer.WriteArray(this, ref context);
}
void ICborConverter <CborArray?> .Write(ref CborWriter writer, CborArray?value, LengthMode lengthMode)
{
if (value == null)
{
writer.WriteNull();
return;
}
ArrayWriterContext arrayWriterContext = new ArrayWriterContext
{
array = value,
lengthMode = lengthMode != LengthMode.Default
? lengthMode : _options.ArrayLengthMode
};
writer.WriteArray(this, ref arrayWriterContext);
}
void ICborConverter <CborObject?> .Write(ref CborWriter writer, CborObject?value, LengthMode lengthMode)
{
if (value == null)
{
writer.WriteNull();
return;
}
MapWriterContext mapWriterContext = new MapWriterContext
{
obj = value,
enumerator = value.GetEnumerator(),
lengthMode = lengthMode != LengthMode.Default
? lengthMode : _options.MapLengthMode
};
writer.WriteMap(this, ref mapWriterContext);
}
public void SetEncodedValue_KnownHeaders_ThrowIf_IncorrectValue()
{
var writer = new CborWriter();
writer.WriteNull();
byte[] encodedNullValue = writer.Encode();
var map = new CoseHeaderMap();
// only accepts int or tstr
Assert.Throws <InvalidOperationException>(() => map.SetEncodedValue(CoseHeaderLabel.Algorithm, encodedNullValue));
// [ +label ] (non-empty array) Not yet properly supported.
//Assert.Throws<NotSupportedException>(() => map.SetEncodedValue(CoseHeaderLabel.Critical, encodedNullValue));
// tstr / uint
Assert.Throws <InvalidOperationException>(() => map.SetEncodedValue(CoseHeaderLabel.ContentType, encodedNullValue));
// bstr
Assert.Throws <InvalidOperationException>(() => map.SetEncodedValue(CoseHeaderLabel.KeyIdentifier, encodedNullValue));
// bstr
Assert.Throws <InvalidOperationException>(() => map.SetEncodedValue(CoseHeaderLabel.IV, encodedNullValue));
// bstr
Assert.Throws <InvalidOperationException>(() => map.SetEncodedValue(CoseHeaderLabel.PartialIV, encodedNullValue));
}
