public void CanCreateBinaryDataFromBytes()
{
byte[] payload = Encoding.UTF8.GetBytes("some data");
BinaryData data = BinaryData.FromBytes(payload);
Assert.Equal(payload, data.ToArray());
MemoryMarshal.TryGetArray <byte>(payload, out ArraySegment <byte> array);
Assert.Same(payload, array.Array);
// using implicit conversion
ReadOnlyMemory <byte> bytes = data;
Assert.Equal(payload, bytes.ToArray());
// using implicit conversion
ReadOnlySpan <byte> span = data;
Assert.Equal(payload, span.ToArray());
// using implicit conversion from null
BinaryData nullData = null;
ReadOnlyMemory <byte> emptyBytes = nullData;
Assert.True(emptyBytes.IsEmpty);
// using implicit conversion from null
ReadOnlySpan <byte> emptySpan = nullData;
Assert.True(emptySpan.IsEmpty);
}
public async Task DownloadStreamingRange(int offset, int length)
{
await using DisposingContainer test = await BlobsClientBuilder.GetTestContainerAsync();
// Arrange
const int size = 8 * Constants.KB;
var data = GetRandomBuffer(size);
TestProgress progress = new TestProgress();
var client = test.Container.GetBlobClient(BlobsClientBuilder.GetNewBlobName());
await client.UploadAsync(BinaryData.FromBytes(data));
// Act
var result = await client.DownloadStreamingAsync(
progressHandler : progress,
range : new HttpRange(offset, length));
var downloadedData = new byte[result.Value.Details.ContentLength];
using (Stream ms = new MemoryStream(downloadedData))
{
await result.Value.Content.CopyToAsync(ms);
}
// Assert
Assert.AreNotEqual(0, progress.List.Count);
Assert.AreEqual(length, progress.List.Max());
Assert.IsTrue(new ReadOnlySpan <byte>(data, offset, length).SequenceEqual(downloadedData));
}
public async Task AttestOpenEnclaveShared()
{
byte[] binaryReport = Base64Url.Decode(_openEnclaveReport);
byte[] binaryRuntimeData = Base64Url.Decode(_runtimeData);
var client = TestEnvironment.GetSharedAttestationClient(this);
IReadOnlyList <AttestationSigner> signingCertificates = (await client.GetSigningCertificatesAsync()).Value;
{
// Collect quote and enclave held data from an SGX enclave.
var attestationResult = await client.AttestOpenEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryReport),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), false),
});
// Confirm that the attestation token contains the enclave held data we specified.
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.EnclaveHeldData.ToArray());
// VERIFY ATTESTATIONRESULT.
// Encrypt Data using DeprecatedEnclaveHeldData
// Send to enclave.
}
}
[TestCase(256 * Constants.KB)] // multi-report case
public async Task DownloadStreaming(int size)
{
await using DisposingContainer test = await BlobsClientBuilder.GetTestContainerAsync();
// Arrange
var data = GetRandomBuffer(size);
TestProgress progress = new TestProgress();
var client = test.Container.GetBlobClient(BlobsClientBuilder.GetNewBlobName());
await client.UploadAsync(BinaryData.FromBytes(data));
// Act
var result = await client.DownloadStreamingAsync(
progressHandler : progress);
var downloadedData = new byte[result.Value.Details.ContentLength];
using (Stream ms = new MemoryStream(downloadedData))
{
await result.Value.Content.CopyToAsync(ms);
}
// Assert
Assert.AreNotEqual(0, progress.List.Count);
Assert.AreEqual(size, progress.List.Max());
}
[TestCase(Constants.MB, 100 * Constants.KB, 10)] // multi-report per-partition case
public async Task DownloadTo(int dataLength, int?partitionSize, int?parallelism)
{
await using DisposingContainer test = await BlobsClientBuilder.GetTestContainerAsync();
// Arrange
var data = GetRandomBuffer(dataLength);
TestProgress progress = new TestProgress();
var client = test.Container.GetBlobClient(BlobsClientBuilder.GetNewBlobName());
await client.UploadAsync(BinaryData.FromBytes(data));
// Act
var downloadedData = new MemoryStream();
await client.DownloadToAsync(downloadedData, new BlobDownloadToOptions
{
ProgressHandler = progress,
TransferOptions = new StorageTransferOptions
{
InitialTransferSize = partitionSize,
MaximumTransferSize = partitionSize,
MaximumConcurrency = parallelism
}
});
// Assert
Assert.AreNotEqual(0, progress.List.Count);
Assert.AreEqual(downloadedData.Length, progress.List.Max());
Assert.AreEqual(data.Length, downloadedData.Length);
Assert.IsTrue(Enumerable.SequenceEqual(data, downloadedData.ToArray()));
}
public async Task AttestOpenEnclaveSharedCallbackRejects()
{
byte[] binaryReport = Base64Url.Decode(_openEnclaveReport);
byte[] binaryRuntimeData = Base64Url.Decode(_runtimeData);
bool callbackInvoked = false;
AttestationTokenValidationOptions tokenValidationOptions = new AttestationTokenValidationOptions
{
ValidateExpirationTime = TestEnvironment.IsTalkingToLiveServer,
};
tokenValidationOptions.TokenValidated += (args) =>
{
callbackInvoked = true;
args.IsValid = false;
return(Task.CompletedTask);
};
var client = TestEnvironment.GetSharedAttestationClient(this, tokenValidationOptions);
IReadOnlyList <AttestationSigner> signingCertificates = (await client.GetSigningCertificatesAsync()).Value;
{
// Collect quote and enclave held data from an SGX enclave.
Assert.ThrowsAsync(typeof(AttestationTokenValidationFailedException), async() => await client.AttestOpenEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryReport),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), false),
}));
Assert.IsTrue(callbackInvoked);
}
}
/// <summary>
/// Retrieves the body of an <see cref="AmqpAnnotatedMessage" /> in the form
/// needed by the <see cref="EventData.EventBody" /> accessor.
/// </summary>
///
/// <param name="instance">The instance that this method was invoked on.</param>
///
/// <returns>The body of the <paramref name="instance"/>, in the appropriate form for use by an <see cref="EventData" /> instance.</returns>
///
/// <exception cref="NotSupportedException">The body of the <paramref name="instance" /> cannot be used directly by <see cref="EventData" />.</exception>
///
public static BinaryData GetEventBody(this AmqpAnnotatedMessage instance)
{
if (instance.Body.TryGetData(out IEnumerable <ReadOnlyMemory <byte> > dataBody))
{
return(BinaryData.FromBytes(MessageBody.FromReadOnlyMemorySegments(dataBody)));
}
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, Resources.RawAmqpBodyTypeMask, nameof(EventData), nameof(EventData.EventBody), instance.Body.BodyType, nameof(EventData.GetRawAmqpMessage)));
}
public static IList <BinaryData> GetDataViaDataBody(this AmqpMessage message)
{
IList <BinaryData> dataList = new List <BinaryData>();
foreach (Data data in (message.DataBody ?? Enumerable.Empty <Data>()))
{
dataList.Add(BinaryData.FromBytes(data.GetByteArray()));
}
return(dataList);
}
public void CreateThrowsOnNullArray()
{
byte[] payload = null;
var ex = Assert.Throws <ArgumentNullException>(() => new BinaryData(payload));
Assert.Contains("data", ex.Message);
ex = Assert.Throws <ArgumentNullException>(() => BinaryData.FromBytes(null));
Assert.Contains("data", ex.Message);
}
public async Task <BlobClient[]> CreateBlobsAsync(BlobContainerClient container, int count)
{
BlobClient[] blobs = new BlobClient[count];
for (int i = 0; i < count; i++)
{
blobs[i] = _test.InstrumentClient(container.GetBlobClient("blob" + (++_blobId)));
await blobs[i].UploadAsync(BinaryData.FromBytes(_test.GetRandomBuffer(Constants.KB)));
}
return(blobs);
}
public static IList <ReadOnlyMemory <byte> > GetDataViaDataBody(AmqpMessage message)
{
IList <ReadOnlyMemory <byte> > dataList = new List <ReadOnlyMemory <byte> >();
foreach (Data data in (message.DataBody ?? Enumerable.Empty <Data>()))
{
dataList.Add(BinaryData.FromBytes(GetByteArrayCopy(data)));
}
return(dataList);
}
public async Task ToStreamRespectsArraySegmentBoundaries()
{
var payload = "pre payload post";
var bytes = Encoding.UTF8.GetBytes(payload);
var segment = new ArraySegment <byte>(bytes, 4, 7);
var data = BinaryData.FromBytes((ReadOnlyMemory <byte>)segment);
var stream = data.ToStream();
var sr = new StreamReader(stream);
Assert.AreEqual("payload", await sr.ReadToEndAsync());
}
public async Task ToStreamIsMutatedWhenCustomerOwnsBuffer()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
BinaryData data = BinaryData.FromBytes(buffer);
Stream stream = data.ToStream();
buffer[0] = (byte)'z';
StreamReader sr = new StreamReader(stream);
Assert.Equal("zome data", await sr.ReadToEndAsync());
}
public async Task AttestOpenEnclaveSharedValidateCallback()
{
byte[] binaryReport = Base64Url.Decode(_openEnclaveReport);
byte[] binaryRuntimeData = Base64Url.Decode(_runtimeData);
bool callbackInvoked = false;
AttestationTokenValidationOptions tokenValidationOptions = new AttestationTokenValidationOptions
{
ValidateExpirationTime = TestEnvironment.IsTalkingToLiveServer,
};
tokenValidationOptions.TokenValidated += (args) =>
{
// Verify that the callback can access the enclave held data field.
CollectionAssert.AreEqual(binaryRuntimeData, args.Token.GetBody <AttestationResult>().EnclaveHeldData.ToArray());
// The MAA service always sends a Key ID for the signer.
args.IsValid =
null != args.Signer.CertificateKeyId &&
1 == args.Signer.SigningCertificates.Count &&
null != args.Signer.SigningCertificates[0] &&
TestEnvironment.SharedAttestationUrl == args.Token.Issuer;
callbackInvoked = true;
return(Task.CompletedTask);
};
var client = TestEnvironment.GetSharedAttestationClient(this, tokenValidationOptions);
IReadOnlyList <AttestationSigner> signingCertificates = (await client.GetSigningCertificatesAsync()).Value;
{
// Collect quote and enclave held data from an SGX enclave.
var attestationResult = await client.AttestOpenEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryReport),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), false),
});
// Confirm that the attestation token contains the enclave held data we specified.
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.EnclaveHeldData.ToArray());
#pragma warning disable CS0618 // Type or member is obsolete
Assert.IsNotNull(attestationResult.Value.DeprecatedEnclaveHeldData);
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.DeprecatedEnclaveHeldData.ToArray());
Assert.IsNotNull(attestationResult.Value.DeprecatedEnclaveHeldData2);
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.DeprecatedEnclaveHeldData2.ToArray());
#pragma warning restore CS0618 // Type or member is obsolete
// VERIFY ATTESTATIONRESULT.
// Encrypt Data using DeprecatedEnclaveHeldData
// Send to enclave.
Assert.IsTrue(callbackInvoked);
}
}
public async Task ToStreamRespectsArraySegmentBoundaries()
{
string payload = "pre payload post";
byte[] bytes = Encoding.UTF8.GetBytes(payload);
ArraySegment <byte> segment = new ArraySegment <byte>(bytes, 4, 7);
BinaryData data = BinaryData.FromBytes(segment);
Stream stream = data.ToStream();
StreamReader sr = new StreamReader(stream);
Assert.Equal("payload", await sr.ReadToEndAsync());
}
public void ToStringRespectsArraySegmentBoundaries()
{
string payload = "pre payload post";
byte[] bytes = Encoding.UTF8.GetBytes(payload);
ArraySegment <byte> segment = new ArraySegment <byte>(bytes, 4, 7);
BinaryData data = BinaryData.FromBytes(segment);
Assert.Equal("payload", data.ToString());
data = BinaryData.FromBytes(segment.Array);
Assert.Equal("pre payload post", data.ToString());
}
public void EqualsRespectsReferenceEquality()
{
var payload = Encoding.UTF8.GetBytes("some data");
var a = BinaryData.FromBytes(payload);
var b = BinaryData.FromBytes(payload);
Assert.AreEqual(a, b);
var c = BinaryData.FromBytes(Encoding.UTF8.GetBytes("some data"));
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, "string data");
}
public void EqualsRespectsReferenceEquality()
{
byte[] payload = "some data" u8.ToArray();
BinaryData a = BinaryData.FromBytes(payload);
BinaryData b = BinaryData.FromBytes(payload);
Assert.NotEqual(a, b);
BinaryData c = BinaryData.FromBytes("some data" u8.ToArray());
Assert.NotEqual(a, c);
Assert.False(a.Equals("string data"));
}
public void EqualsRespectsReferenceEquality()
{
byte[] payload = Encoding.UTF8.GetBytes("some data");
BinaryData a = BinaryData.FromBytes(payload);
BinaryData b = BinaryData.FromBytes(payload);
Assert.NotEqual(a, b);
BinaryData c = BinaryData.FromBytes(Encoding.UTF8.GetBytes("some data"));
Assert.NotEqual(a, c);
Assert.False(a.Equals("string data"));
}
private async Task TestBindToBinaryData(byte[] expectedContent)
{
// Arrange
var queue = await CreateQueue(queueServiceClient, QueueName);
await queue.SendMessageAsync(BinaryData.FromBytes(expectedContent));
// Act
BinaryData result = await RunTriggerAsync <BinaryData>(typeof(BindToBinaryDataProgram),
(s) => BindToBinaryDataProgram.TaskSource = s);
// Assert
Assert.AreEqual(expectedContent, result.ToArray());
}
public async Task AttestSgxEnclaveSharedValidateCallback()
{
// An SGX Quote is an OpenEnclave report with the first 16 bytes stripped from it.
var report = Base64Url.Decode(_openEnclaveReport);
var quoteList = report.ToList();
quoteList.RemoveRange(0, 0x10);
byte[] binaryQuote = quoteList.ToArray();
byte[] binaryRuntimeData = Base64Url.Decode(_runtimeData);
bool callbackInvoked = false;
var tokenValidationOptions = new AttestationTokenValidationOptions
{
ValidateExpirationTime = TestEnvironment.IsTalkingToLiveServer,
};
tokenValidationOptions.TokenValidated += (AttestationTokenValidationEventArgs args) =>
{
// Verify that the callback can access the enclave held data field.
CollectionAssert.AreEqual(binaryRuntimeData, args.Token.GetBody <AttestationResult>().EnclaveHeldData.ToArray());
// The MAA service always sends a Key ID for the signer.
Assert.IsNotNull(args.Signer.CertificateKeyId);
Assert.AreEqual(TestEnvironment.SharedAttestationUrl, args.Token.Issuer);
callbackInvoked = true;
return(Task.CompletedTask);
};
var client = TestEnvironment.GetSharedAttestationClient(this, tokenValidationOptions);
IReadOnlyList <AttestationSigner> signingCertificates = (await client.GetSigningCertificatesAsync()).Value;
{
// Collect quote and enclave held data from an SGX enclave.
var attestationResult = await client.AttestSgxEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryQuote),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), false),
});
// Confirm that the attestation token contains the enclave held data we specified.
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.EnclaveHeldData.ToArray());
// VERIFY ATTESTATIONRESULT.
// Encrypt Data using DeprecatedEnclaveHeldData
// Send to enclave.
Assert.IsTrue(callbackInvoked);
}
}
public void CanCreateBinaryDataFromBytes()
{
byte[] payload = Encoding.UTF8.GetBytes("some data");
BinaryData data = BinaryData.FromBytes(payload);
Assert.AreEqual(payload, data.Bytes.ToArray());
MemoryMarshal.TryGetArray <byte>(payload, out var array);
Assert.AreSame(payload, array.Array);
// using implicit conversion
ReadOnlyMemory <byte> bytes = data;
Assert.AreEqual(payload, bytes.ToArray());
}
public void ToStringRespectsArraySegmentBoundaries()
{
var payload = "pre payload post";
var bytes = Encoding.UTF8.GetBytes(payload);
var segment = new ArraySegment <byte>(bytes, 4, 7);
var data = BinaryData.FromBytes((ReadOnlyMemory <byte>)segment);
Assert.AreEqual("payload", data.ToString());
data = BinaryData.FromBytes((ReadOnlySpan <byte>)segment);
Assert.AreEqual("payload", data.ToString());
data = BinaryData.FromBytes(segment.Array);
Assert.AreEqual("pre payload post", data.ToString());
}
/// <summary>
/// Reads the data body of an AMQP message, transforming it for use
/// as the body of an <see cref="EventData" /> instance.
/// </summary>
///
/// <param name="body">The body data set of an AMQP message.</param>
///
/// <returns>A <see cref="BinaryData" /> representation of the <paramref name="body"/>.</returns>
///
private static BinaryData ReadAmqpDataBody(IEnumerable <Data> body)
{
var writer = new ArrayBufferWriter <byte>();
foreach (var data in body)
{
var dataBytes = GetDataBytes(data);
dataBytes.CopyTo(writer.GetMemory(dataBytes.Length));
writer.Advance(dataBytes.Length);
}
return((writer.WrittenCount > 0)
? BinaryData.FromBytes(writer.WrittenMemory)
: new BinaryData(Array.Empty <byte>()));
}
public async Task AttestSgxEnclaveShared()
{
// An SGX Quote is an OpenEnclave report with the first 16 bytes stripped from it.
var report = Base64Url.Decode(_openEnclaveReport);
var quoteList = report.ToList();
quoteList.RemoveRange(0, 0x10);
byte[] binaryQuote = quoteList.ToArray();
byte[] binaryRuntimeData = Base64Url.Decode(_runtimeData);
var client = TestEnvironment.GetSharedAttestationClient(this);
IReadOnlyList <AttestationSigner> signingCertificates = (await client.GetSigningCertificatesAsync()).Value;
{
// Collect quote and enclave held data from an SGX enclave.
var attestationResult = await client.AttestSgxEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryQuote),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), false),
});
// Confirm that the attestation token contains the enclave held data we specified.
CollectionAssert.AreEqual(binaryRuntimeData, attestationResult.Value.EnclaveHeldData.ToArray());
// VERIFY ATTESTATIONRESULT.
// Encrypt Data using DeprecatedEnclaveHeldData
// Send to enclave.
}
{
// Collect quote and enclave held data from an SGX enclave.
var attestationResult = await client.AttestSgxEnclaveAsync(
new AttestationRequest
{
Evidence = BinaryData.FromBytes(binaryQuote),
RuntimeData = new AttestationData(BinaryData.FromBytes(binaryRuntimeData), true),
});
// Confirm that the attestation token contains the enclave held data we specified.
Assert.IsNull(attestationResult.Value.EnclaveHeldData);
// VERIFY ATTESTATIONRESULT.
// Encrypt Data using DeprecatedEnclaveHeldData
// Send to enclave.
}
}
public async Task RunAsync()
{
// Fetch file
var enclaveInfo = await EnclaveInfo.CreateFromFileAsync(this.fileName);
// Send to service for attestation
string endpoint = "https://" + this.attestDnsName;
// Send to service for attestation
var options = new AttestationClientOptions(tokenOptions: new AttestationTokenValidationOptions
{
ExpectedIssuer = endpoint,
ValidateIssuer = true,
}
);
options.TokenOptions.TokenValidated += (args) =>
{
// Analyze results
Logger.WriteBanner("IN VALIDATION CALLBACK, VALIDATING MAA JWT TOKEN - BASICS");
JwtValidationHelper.ValidateMaaJwt(attestDnsName, args.Token, args.Signer, this.includeDetails);
args.IsValid = true;
return(Task.CompletedTask);
};
var maaService = new AttestationClient(new Uri(endpoint), new DefaultAzureCredential(), options);
BinaryData openEnclaveReport = BinaryData.FromBytes(HexHelper.ConvertHexToByteArray(enclaveInfo.QuoteHex));
BinaryData runtimeData = BinaryData.FromBytes(HexHelper.ConvertHexToByteArray(enclaveInfo.EnclaveHeldDataHex));
var serviceResponse = await maaService.AttestOpenEnclaveAsync(
new AttestationRequest
{
Evidence = openEnclaveReport,
RuntimeData = new AttestationData(runtimeData, false),
});
var serviceJwtToken = serviceResponse.Token.ToString();
Logger.WriteBanner("VALIDATING MAA JWT TOKEN - MATCHES CLIENT ENCLAVE INFO");
enclaveInfo.CompareToMaaServiceJwtToken(serviceResponse.Value, this.includeDetails);
}
public async Task QueueTrigger_IfMessageIsUtf8ByteArray_ProvidesQueueTriggerBindingData()
{
// Arrange
const string expectedQueueTrigger = "abc";
byte[] content = Encoding.UTF8.GetBytes(expectedQueueTrigger);
var queue = await CreateQueue(queueServiceClient, QueueName);
await queue.SendMessageAsync(BinaryData.FromBytes(content));
// Act
string result = await RunTriggerAsync <string>(typeof(BindToQueueTriggerBindingDataProgram),
(s) => BindToQueueTriggerBindingDataProgram.TaskSource = s);
// Assert
Assert.AreEqual(expectedQueueTrigger, result);
}
// Returns via the out parameter the flattened collection of bytes.
// A majority of the time, data will only contain 1 element.
// The method is optimized for this situation to return the pre-existing array.
public static BinaryData ConvertAndFlattenData(this IEnumerable <ReadOnlyMemory <byte> > dataList)
{
var writer = new ArrayBufferWriter <byte>();
Memory <byte> memory;
foreach (ReadOnlyMemory <byte> data in dataList)
{
memory = writer.GetMemory(data.Length);
data.CopyTo(memory);
writer.Advance(data.Length);
}
if (writer.WrittenCount == 0)
{
return(new BinaryData(Array.Empty <byte>()));
}
return(BinaryData.FromBytes(writer.WrittenMemory));
}
// Returns via the out parameter the flattened collection of bytes.
// A majority of the time, data will only contain 1 element.
// The method is optimized for this situation to return the pre-existing array.
public static BinaryData ConvertAndFlattenData(this IEnumerable <BinaryData> dataList)
{
var writer = new ArrayBufferWriter <byte>();
Memory <byte> memory;
foreach (BinaryData data in dataList)
{
ReadOnlyMemory <byte> bytes = data.ToBytes();
memory = writer.GetMemory(bytes.Length);
bytes.CopyTo(memory);
writer.Advance(bytes.Length);
}
if (writer.WrittenCount == 0)
{
return(new BinaryData());
}
return(BinaryData.FromBytes(writer.WrittenMemory));
}
public void ToFromBytes()
{
#region Snippet:BinaryDataToFromBytes
var bytes = Encoding.UTF8.GetBytes("some data");
// when using the ReadOnlySpan constructor the underlying data is copied.
var data = new BinaryData(new ReadOnlySpan <byte>(bytes));
// when using the static factory method, the data is wrapped
data = BinaryData.FromBytes(bytes);
// there is an implicit cast defined for ReadOnlyMemory<byte>
ReadOnlyMemory <byte> rom = data;
// there is also a Bytes property that holds the data
rom = data.Bytes;
#endregion
}