public static BlobServiceClient GetServiceClient_BlobServiceSas_Container(
string containerName,
SharedKeyCredentials sharedKeyCredentials = default,
SasQueryParameters sasCredentials = default)
=> new BlobServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.BlobServiceEndpoint}?{sasCredentials ?? GetNewBlobServiceSasCredentialsContainer(containerName: containerName, sharedKeyCredentials: sharedKeyCredentials ?? GetNewSharedKeyCredentials())}"),
GetOptions <BlobConnectionOptions>());
/// <summary>
/// Use an account's <see cref="SharedKeyCredentials"/> to sign this
/// shared access signature values to produce the proper SAS query
/// parameters for authenticating requests.
/// </summary>
/// <param name="sharedKeyCredential">
/// The storage account's <see cref="SharedKeyCredentials"/>.
/// </param>
/// <returns>
/// The <see cref="SasQueryParameters"/> used for authenticating requests.
/// </returns>
public SasQueryParameters ToSasQueryParameters(SharedKeyCredentials sharedKeyCredential)
{
sharedKeyCredential = sharedKeyCredential ?? throw Errors.ArgumentNull(nameof(sharedKeyCredential));
string resource;
if (String.IsNullOrEmpty(this.FilePath))
{
// Make sure the permission characters are in the correct order
this.Permissions = ShareSasPermissions.Parse(this.Permissions).ToString();
resource = Constants.Sas.Resource.Share;
}
else
{
// Make sure the permission characters are in the correct order
this.Permissions = FileSasPermissions.Parse(this.Permissions).ToString();
resource = Constants.Sas.Resource.File;
}
if (String.IsNullOrEmpty(this.Version))
{
this.Version = SasQueryParameters.SasVersion;
}
var startTime = SasQueryParameters.FormatTimesForSasSigning(this.StartTime);
var expiryTime = SasQueryParameters.FormatTimesForSasSigning(this.ExpiryTime);
// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
var stringToSign = String.Join("\n",
this.Permissions,
startTime,
expiryTime,
GetCanonicalName(sharedKeyCredential.AccountName, this.ShareName ?? String.Empty, this.FilePath ?? String.Empty),
this.Identifier,
this.IPRange.ToString(),
this.Protocol.ToString(),
this.Version,
this.CacheControl,
this.ContentDisposition,
this.ContentEncoding,
this.ContentLanguage,
this.ContentType);
var signature = sharedKeyCredential.ComputeHMACSHA256(stringToSign);
var p = new SasQueryParameters(
version: this.Version,
services: null,
resourceTypes: null,
protocol: this.Protocol,
startTime: this.StartTime,
expiryTime: this.ExpiryTime,
ipRange: this.IPRange,
identifier: this.Identifier,
resource: resource,
permissions: this.Permissions,
signature: signature);
return(p);
}
public BlobServiceClient GetServiceClient_AccountSas(
SharedKeyCredentials sharedKeyCredentials = default,
SasQueryParameters sasCredentials = default)
=> this.InstrumentClient(
new BlobServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.BlobServiceEndpoint}?{sasCredentials ?? this.GetNewAccountSasCredentials(sharedKeyCredentials ?? this.GetNewSharedKeyCredentials())}"),
this.GetOptions()));
public async Task ConnectWithInvalidConnectionStringTest()
{
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), TokenProvider, DeviceScopeIdentitiesCache, TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity1 = Mock.Of <IIdentity>(m => m.Id == "device1");
var clientCredentials1 = new SharedKeyCredentials(deviceIdentity1, "dummyConnStr", null);
Try <ICloudConnection> result = await cloudConnectionProvider.Connect(clientCredentials1, null);
Assert.False(result.Success);
Assert.IsType <AggregateException>(result.Exception);
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
// Change the connection string key, deliberately.
char updatedLastChar = (char)(deviceConnectionString[deviceConnectionString.Length - 1] + 1);
deviceConnectionString = deviceConnectionString.Substring(0, deviceConnectionString.Length - 1) + updatedLastChar;
var deviceIdentity2 = Mock.Of <IIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials2 = new SharedKeyCredentials(deviceIdentity2, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials2, null).Result;
Assert.False(cloudProxy.Success);
}
public void DefaultStorageAccountWithHttps()
{
var cred = new SharedKeyCredentials(TestConfigurations.DefaultTargetTenant.AccountName, TestConfigurations.DefaultTargetTenant.AccountKey);
var conn = new StorageConnectionString(cred, true);
Assert.AreEqual(conn.BlobEndpoint,
new Uri(String.Format("https://{0}.blob.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.QueueEndpoint,
new Uri(String.Format("https://{0}.queue.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.TableEndpoint,
new Uri(String.Format("https://{0}.table.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.FileEndpoint,
new Uri(String.Format("https://{0}.file.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.BlobStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.blob.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.QueueStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.queue.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.TableStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.table.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
Assert.AreEqual(conn.FileStorageUri.SecondaryUri,
new Uri(String.Format("https://{0}-secondary.file.core.windows.net", TestConfigurations.DefaultTargetTenant.AccountName)));
var storageConnectionStringToStringWithSecrets = conn.ToString(true);
var testAccount = StorageConnectionString.Parse(storageConnectionStringToStringWithSecrets);
this.AccountsAreEqual(testAccount, conn);
}
async Task <ICloudProxy> GetCloudProxyWithConnectionStringKey(string connectionStringConfigKey, IEdgeHub edgeHub)
{
const int ConnectionPoolSize = 10;
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey(connectionStringConfigKey);
var converters = new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Client.Message), new DeviceClientMessageConverter() },
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(converters, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60), true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, string.Empty);
Try <ICloudConnection> cloudConnection = await cloudConnectionProvider.Connect(clientCredentials, (_, __) => { });
Assert.True(cloudConnection.Success);
Assert.True(cloudConnection.Value.IsActive);
Assert.True(cloudConnection.Value.CloudProxy.HasValue);
return(cloudConnection.Value.CloudProxy.OrDefault());
}
public BlobServiceClient GetServiceClient_BlobServiceSas_Blob(
string containerName,
string blobName,
SharedKeyCredentials sharedKeyCredentials = default,
SasQueryParameters sasCredentials = default)
=> this.InstrumentClient(
new BlobServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.BlobServiceEndpoint}?{sasCredentials ?? this.GetNewBlobServiceSasCredentialsBlob(containerName: containerName, blobName: blobName, sharedKeyCredentials: sharedKeyCredentials ?? this.GetNewSharedKeyCredentials())}"),
this.GetOptions()));
public async Task TestAddRemoveDeviceConnectionTest()
{
string deviceId = "id1";
var deviceProxyMock1 = new Mock <IDeviceProxy>();
deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(true);
deviceProxyMock1.Setup(dp => dp.CloseAsync(It.IsAny <Exception>()))
.Callback(() => deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(false))
.Returns(Task.FromResult(true));
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", deviceId), "dummyConnStr", "abc");
var edgeHub = new Mock <IEdgeHub>();
IClient client = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Returns(client);
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider);
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(cloudProxyTry.Success);
var deviceListener = new DeviceMessageHandler(deviceCredentials.Identity, edgeHub.Object, connectionManager);
Option <ICloudProxy> cloudProxy = connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
deviceListener.BindDeviceProxy(deviceProxyMock1.Object);
Option <IDeviceProxy> deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.True(deviceProxy.HasValue);
Assert.True(deviceProxy.OrDefault().IsActive);
Assert.True(deviceProxyMock1.Object.IsActive);
cloudProxy = connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
await deviceListener.CloseAsync();
deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.False(deviceProxy.HasValue);
Assert.False(deviceProxyMock1.Object.IsActive);
cloudProxy = connectionManager.GetCloudConnection(deviceId);
Assert.False(cloudProxy.HasValue);
Assert.False(client.IsActive);
}
public void Ctor_ConnectionString()
{
var accountName = "accountName";
var accountKey = Convert.ToBase64String(new byte[] { 0, 1, 2, 3, 4, 5 });
var credentials = new SharedKeyCredentials(accountName, accountKey);
var queueEndpoint = new Uri("http://127.0.0.1/" + accountName);
var queueSecondaryEndpoint = new Uri("http://127.0.0.1/" + accountName + "-secondary");
var connectionString = new StorageConnectionString(credentials, (default, default), (queueEndpoint, queueSecondaryEndpoint), (default, default), (default, default));
public BlobConnectionOptions GetFaultyBlobConnectionOptions(
SharedKeyCredentials credentials = null,
int raiseAt = default,
Exception raise = default)
{
raise = raise ?? new Exception("Simulated connection fault");
var options = this.GetOptions(credentials);
options.AddPolicy(HttpPipelinePosition.PerCall, new FaultyDownloadPipelinePolicy(raiseAt, raise));
return(options);
}
public static BlobConnectionOptions GetFaultyBlobConnectionOptions(
SharedKeyCredentials credentials = null,
int raiseAt = default,
Exception raise = default)
{
raise = raise ?? new Exception("Simulated connection fault");
var options = GetOptions <BlobConnectionOptions>(credentials);
options.PerCallPolicies.Add(new FaultyDownloadPipelinePolicy(raiseAt, raise));
return(options);
}
public async Task ConnectTest()
{
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>());
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials, null).Result;
Assert.True(cloudProxy.Success);
bool result = await cloudProxy.Value.CloseAsync();
Assert.True(result);
}
public SasQueryParameters GetNewQueueServiceSasCredentials(string queueName, SharedKeyCredentials sharedKeyCredentials = default)
=> new QueueSasBuilder
{
QueueName = queueName,
Protocol = SasProtocol.None,
StartTime = this.Recording.UtcNow.AddHours(-1),
ExpiryTime = this.Recording.UtcNow.AddHours(+1),
Permissions = new QueueAccountSasPermissions {
Read = true, Update = true, Process = true, Add = true
}.ToString(),
IPRange = new IPRange {
Start = IPAddress.None, End = IPAddress.None
}
}
.ToSasQueryParameters(sharedKeyCredentials ?? this.GetNewSharedKeyCredentials());
public async Task CreateCloudProxyTest()
{
string edgeDeviceId = "edgeDevice";
string module1Id = "module1";
var module1Credentials = new SharedKeyCredentials(new ModuleIdentity("iotHub", edgeDeviceId, module1Id), "connStr", DummyProductInfo);
IClient client1 = GetDeviceClient();
IClient client2 = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Returns(client1)
.Returns(client2);
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, EdgeDeviceId, EdgeModuleId);
Task <Try <ICloudProxy> > getCloudProxyTask1 = connectionManager.CreateCloudConnectionAsync(module1Credentials);
Task <Try <ICloudProxy> > getCloudProxyTask2 = connectionManager.CreateCloudConnectionAsync(module1Credentials);
Try <ICloudProxy>[] cloudProxies = await Task.WhenAll(getCloudProxyTask1, getCloudProxyTask2);
Assert.NotEqual(cloudProxies[0].Value, cloudProxies[1].Value);
Option <ICloudProxy> currentCloudProxyId1 = await connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
ICloudProxy currentCloudProxy = currentCloudProxyId1.OrDefault();
ICloudProxy cloudProxy1 = cloudProxies[0].Value;
ICloudProxy cloudProxy2 = cloudProxies[1].Value;
Assert.True(currentCloudProxy == cloudProxy1 || currentCloudProxy == cloudProxy2);
if (currentCloudProxy == cloudProxy1)
{
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Never);
}
else
{
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Never);
}
}
public async Task CloudConnectionInvalidUpdateTest()
{
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Returns(GetDeviceClient())
.Throws(new UnauthorizedException("connstr2 is invalid!"))
.Throws(new UnauthorizedException("connstr2 is invalid!"));
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, EdgeDeviceId, EdgeModuleId);
string deviceConnStr1 = "connstr1";
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr1, DummyProductInfo);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
await connectionManager.AddDeviceConnection(deviceCredentials.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
string deviceConnStr2 = "connstr2";
deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr2, DummyProductInfo);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.False(receivedCloudProxy2.Success);
Assert.IsType <EdgeHubConnectionException>(receivedCloudProxy2.Exception);
List <Exception> innerExceptions = (receivedCloudProxy2.Exception.InnerException as AggregateException)?.InnerExceptions.ToList() ?? new List <Exception>();
Assert.Equal(2, innerExceptions.Count);
Assert.IsType <UnauthorizedException>(innerExceptions[0]);
Assert.IsType <UnauthorizedException>(innerExceptions[1]);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
}
/// <summary>
/// Use an account's <see cref="SharedKeyCredentials"/> to sign this
/// shared access signature values to produce the proper SAS query
/// parameters for authenticating requests.
/// </summary>
/// <param name="sharedKeyCredential">
/// The storage account's <see cref="SharedKeyCredentials"/>.
/// </param>
/// <returns>
/// The <see cref="SasQueryParameters"/> used for authenticating requests.
/// </returns>
public SasQueryParameters ToSasQueryParameters(SharedKeyCredentials sharedKeyCredential)
{
sharedKeyCredential = sharedKeyCredential ?? throw new ArgumentNullException(nameof(sharedKeyCredential));
this.EnsureState();
var startTime = SasQueryParameters.FormatTimesForSasSigning(this.StartTime);
var expiryTime = SasQueryParameters.FormatTimesForSasSigning(this.ExpiryTime);
// See http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
var stringToSign = String.Join("\n",
this.Permissions,
startTime,
expiryTime,
GetCanonicalName(sharedKeyCredential.AccountName, this.ContainerName ?? String.Empty, this.BlobName ?? String.Empty),
this.Identifier,
this.IPRange.ToString(),
this.Protocol.ToString(),
this.Version,
this.Resource,
this.Snapshot,
this.CacheControl,
this.ContentDisposition,
this.ContentEncoding,
this.ContentLanguage,
this.ContentType);
var signature = sharedKeyCredential.ComputeHMACSHA256(stringToSign);
var p = new SasQueryParameters(
version: this.Version,
services: null,
resourceTypes: null,
protocol: this.Protocol,
startTime: this.StartTime,
expiryTime: this.ExpiryTime,
ipRange: this.IPRange,
identifier: this.Identifier,
resource: this.Resource,
permissions: this.Permissions,
signature: signature);
return(p);
}
public async Task CloudConnectionUpdateTest()
{
string receivedConnStr = null;
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Callback <IIdentity, string, Client.ITransportSettings[]>((i, s, t) => receivedConnStr = s)
.Returns(() => GetDeviceClient());
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, EdgeDeviceId, EdgeModuleId);
string deviceConnStr1 = "connstr1";
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr1, DummyProductInfo);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
await connectionManager.AddDeviceConnection(deviceCredentials.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceConnStr1, receivedConnStr);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
string deviceConnStr2 = "connstr2";
deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr2, DummyProductInfo);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(receivedCloudProxy2.Success);
Assert.NotNull(receivedCloudProxy2.Value);
Assert.True(receivedCloudProxy2.Value.IsActive);
Assert.False(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceConnStr2, receivedConnStr);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
}
public SasQueryParameters GetNewAccountSasCredentials(SharedKeyCredentials sharedKeyCredentials = default)
=> new AccountSasSignatureValues
{
Protocol = SasProtocol.None,
Services = new AccountSasServices {
Blob = true
}.ToString(),
ResourceTypes = new AccountSasResourceTypes {
Container = true, Object = true
}.ToString(),
StartTime = this.Recording.UtcNow.AddHours(-1),
ExpiryTime = this.Recording.UtcNow.AddHours(+1),
Permissions = new ContainerSasPermissions {
Read = true, Add = true, Create = true, Write = true, Delete = true, List = true
}.ToString(),
IPRange = new IPRange {
Start = IPAddress.None, End = IPAddress.None
}
}
.ToSasQueryParameters(sharedKeyCredentials);
public static SasQueryParameters GetNewAccountSasCredentials(SharedKeyCredentials sharedKeyCredentials = default)
=> new AccountSasSignatureValues
{
Protocol = SasProtocol.None,
Services = new AccountSasServices {
Queue = true
}.ToString(),
ResourceTypes = new AccountSasResourceTypes {
Container = true
}.ToString(),
StartTime = DateTimeOffset.UtcNow.AddHours(-1),
ExpiryTime = DateTimeOffset.UtcNow.AddHours(+1),
Permissions = new QueueAccountSasPermissions {
Read = true, Write = true, Update = true, Process = true, Add = true, Delete = true, List = true
}.ToString(),
IPRange = new IPRange {
Start = IPAddress.None, End = IPAddress.None
}
}
.ToSasQueryParameters(sharedKeyCredentials);
public async Task MutipleModulesConnectionTest()
{
string iotHubHostName = "iotHubName";
string edgeDeviceId = "edge";
string edgeDeviceConnStr = "dummyConnStr";
var module1Credentials = new TokenCredentials(new ModuleIdentity(iotHubHostName, edgeDeviceId, "module1"), "xyz", DummyProductInfo, false);
var module2Credentials = new TokenCredentials(new ModuleIdentity(iotHubHostName, edgeDeviceId, "module2"), "xyz", DummyProductInfo, false);
var edgeDeviceCredentials = new SharedKeyCredentials(new DeviceIdentity(iotHubHostName, edgeDeviceId), edgeDeviceConnStr, "abc");
var device1Credentials = new TokenCredentials(new DeviceIdentity(iotHubHostName, edgeDeviceId), "pqr", DummyProductInfo, false);
var cloudConnectionProvider = Mock.Of <ICloudConnectionProvider>();
Mock.Get(cloudConnectionProvider)
.Setup(c => c.Connect(It.IsAny <IClientCredentials>(), It.IsAny <Action <string, CloudConnectionStatus> >()))
.ReturnsAsync(() => Try.Success(GetCloudConnectionMock()));
var credentialsManager = Mock.Of <ICredentialsCache>();
var connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsManager, GetIdentityProvider());
Try <ICloudProxy> module1CloudProxy = await connectionManager.CreateCloudConnectionAsync(module1Credentials);
Assert.True(module1CloudProxy.Success);
Assert.NotNull(module1CloudProxy.Value);
Try <ICloudProxy> module2CloudProxy = await connectionManager.CreateCloudConnectionAsync(module2Credentials);
Assert.True(module2CloudProxy.Success);
Assert.NotEqual(module1CloudProxy.Value, module2CloudProxy.Value);
Try <ICloudProxy> edgeDeviceCloudProxy = await connectionManager.CreateCloudConnectionAsync(edgeDeviceCredentials);
Assert.True(edgeDeviceCloudProxy.Success);
Assert.NotEqual(module1CloudProxy.Value, edgeDeviceCloudProxy.Value);
Try <ICloudProxy> device1CloudProxy = await connectionManager.CreateCloudConnectionAsync(device1Credentials);
Assert.True(device1CloudProxy.Success);
Assert.NotEqual(edgeDeviceCloudProxy.Value, device1CloudProxy.Value);
}
/// <summary>
/// ToSasQueryParameters uses an account's shared key credential to sign this signature values to produce
/// the proper SAS query parameters.
/// </summary>
/// <param name="sharedKeyCredential">
/// <see cref="SharedKeyCredentials"/>
/// </param>
/// <returns>
/// <see cref="SasQueryParameters"/>
/// </returns>
public SasQueryParameters ToSasQueryParameters(SharedKeyCredentials sharedKeyCredential)
{
sharedKeyCredential = sharedKeyCredential ?? throw Errors.ArgumentNull(nameof(sharedKeyCredential));
this.Permissions = QueueAccountSasPermissions.Parse(this.Permissions).ToString();
if (String.IsNullOrEmpty(this.Version))
{
this.Version = SasQueryParameters.SasVersion;
}
var startTime = SasQueryParameters.FormatTimesForSasSigning(this.StartTime);
var expiryTime = SasQueryParameters.FormatTimesForSasSigning(this.ExpiryTime);
// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
var stringToSign = String.Join("\n",
this.Permissions,
startTime,
expiryTime,
GetCanonicalName(sharedKeyCredential.AccountName, this.QueueName ?? String.Empty),
this.Identifier,
this.IPRange.ToString(),
this.Protocol.ToString(),
this.Version);
var signature = sharedKeyCredential.ComputeHMACSHA256(stringToSign);
var p = new SasQueryParameters(
version: this.Version,
services: null,
resourceTypes: null,
protocol: this.Protocol,
startTime: this.StartTime,
expiryTime: this.ExpiryTime,
ipRange: this.IPRange,
identifier: this.Identifier,
resource: null,
permissions: this.Permissions,
signature: signature);
return(p);
}
public void StorageCredentialsEmptyKeyValue()
{
var accountName = TestConfigurations.DefaultTargetTenant.AccountName;
_ = TestConfigurations.DefaultTargetTenant.AccountKey;
var emptyKeyValueAsString = String.Empty;
var emptyKeyConnectionString = String.Format(CultureInfo.InvariantCulture, "DefaultEndpointsProtocol=https;AccountName={0};AccountKey=", accountName);
var credentials1 = new SharedKeyCredentials(accountName, emptyKeyValueAsString);
var conn1 = new StorageConnectionString(credentials1, true);
Assert.AreEqual(emptyKeyConnectionString, conn1.ToString(true));
Assert.IsNotNull(conn1.Credentials);
Assert.IsInstanceOf(typeof(SharedKeyCredentials), conn1.Credentials);
Assert.AreEqual(accountName, ((SharedKeyCredentials)conn1.Credentials).AccountName);
Assert.AreEqual(emptyKeyValueAsString, ((SharedKeyCredentials)conn1.Credentials).ExportBase64EncodedKey());
var account2 = StorageConnectionString.Parse(emptyKeyConnectionString);
Assert.AreEqual(emptyKeyConnectionString, account2.ToString(true));
Assert.IsNotNull(account2.Credentials);
Assert.IsInstanceOf(typeof(SharedKeyCredentials), account2.Credentials);
Assert.AreEqual(accountName, ((SharedKeyCredentials)account2.Credentials).AccountName);
Assert.AreEqual(emptyKeyValueAsString, ((SharedKeyCredentials)account2.Credentials).ExportBase64EncodedKey());
var isValidAccount3 = StorageConnectionString.TryParse(emptyKeyConnectionString, out var account3);
Assert.IsTrue(isValidAccount3);
Assert.IsNotNull(account3);
Assert.AreEqual(emptyKeyConnectionString, account3.ToString(true));
Assert.IsNotNull(account3.Credentials);
Assert.IsInstanceOf(typeof(SharedKeyCredentials), account3.Credentials);
Assert.AreEqual(accountName, ((SharedKeyCredentials)account3.Credentials).AccountName);
Assert.AreEqual(emptyKeyValueAsString, ((SharedKeyCredentials)account3.Credentials).ExportBase64EncodedKey());
}
// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
// the proper SAS query parameters.
public SasQueryParameters ToSasQueryParameters(SharedKeyCredentials sharedKeyCredential)
{
// https://docs.microsoft.com/en-us/rest/api/storageservices/Constructing-an-Account-SAS
sharedKeyCredential = sharedKeyCredential ?? throw Errors.ArgumentNull(nameof(sharedKeyCredential));
if (this.ExpiryTime == default || String.IsNullOrEmpty(this.Permissions) || String.IsNullOrEmpty(this.ResourceTypes) || String.IsNullOrEmpty(this.Services))
{
throw Errors.AccountSasMissingData();
}
if (String.IsNullOrEmpty(this.Version))
{
this.Version = SasQueryParameters.SasVersion;
}
// Make sure the permission characters are in the correct order
this.Permissions = AccountSasPermissions.Parse(this.Permissions).ToString();
var startTime = SasQueryParameters.FormatTimesForSasSigning(this.StartTime);
var expiryTime = SasQueryParameters.FormatTimesForSasSigning(this.ExpiryTime);
// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
var stringToSign = String.Join("\n",
sharedKeyCredential.AccountName,
this.Permissions,
this.Services,
this.ResourceTypes,
startTime,
expiryTime,
this.IPRange.ToString(),
this.Protocol.ToString(),
this.Version,
""); // That's right, the account SAS requires a terminating extra newline
var signature = sharedKeyCredential.ComputeHMACSHA256(stringToSign);
var p = new SasQueryParameters(this.Version, this.Services, this.ResourceTypes, this.Protocol, this.StartTime, this.ExpiryTime, this.IPRange, null, null, this.Permissions, signature);
return(p);
}
public QueueServiceClient GetServiceClient_QueueServiceSas(string queueName, SharedKeyCredentials sharedKeyCredentials = default, SasQueryParameters sasCredentials = default)
=> this.InstrumentClient(
new QueueServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.QueueServiceEndpoint}?{sasCredentials ?? this.GetNewQueueServiceSasCredentials(queueName, sharedKeyCredentials ?? this.GetNewSharedKeyCredentials())}"),
this.GetOptions()));
public SasQueryParameters GetNewBlobServiceSasCredentialsSnapshot(string containerName, string blobName, string snapshot, SharedKeyCredentials sharedKeyCredentials = default)
=> new BlobSasBuilder
{
ContainerName = containerName,
BlobName = blobName,
Snapshot = snapshot,
Protocol = SasProtocol.None,
StartTime = this.Recording.UtcNow.AddHours(-1),
ExpiryTime = this.Recording.UtcNow.AddHours(+1),
Permissions = new SnapshotSasPermissions {
Read = true, Write = true, Delete = true
}.ToString(),
IPRange = new IPRange {
Start = IPAddress.None, End = IPAddress.None
}
}
.ToSasQueryParameters(sharedKeyCredentials ?? this.GetNewSharedKeyCredentials());
/// <summary>
/// Construct options for making service requests signed with an Azure
/// Queue Storage shared key.
/// </summary>
/// <param name="credentials">
/// The <see cref="SharedKeyCredentials"/> used to sign requests.
/// </param>
public QueueConnectionOptions(SharedKeyCredentials credentials)
: base(credentials)
{
}
public static SasQueryParameters GetNewBlobServiceSasCredentialsBlob(string containerName, string blobName, SharedKeyCredentials sharedKeyCredentials = default)
=> new BlobSasBuilder
{
ContainerName = containerName,
BlobName = blobName,
Protocol = SasProtocol.None,
StartTime = DateTimeOffset.UtcNow.AddHours(-1),
ExpiryTime = DateTimeOffset.UtcNow.AddHours(+1),
Permissions = new BlobSasPermissions {
Read = true, Add = true, Create = true, Write = true, Delete = true
}.ToString(),
IPRange = new IPRange {
Start = IPAddress.None, End = IPAddress.None
}
}
.ToSasQueryParameters(sharedKeyCredentials ?? GetNewSharedKeyCredentials());
public static BlobServiceClient GetServiceClient_AccountSas(
SharedKeyCredentials sharedKeyCredentials = default,
SasQueryParameters sasCredentials = default)
=> new BlobServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.BlobServiceEndpoint}?{sasCredentials ?? GetNewAccountSasCredentials(sharedKeyCredentials ?? GetNewSharedKeyCredentials())}"),
GetOptions <BlobConnectionOptions>());
/// <summary>
/// Initializes a new instance of the <see cref="BlobConnectionOptions"/>
/// class for making service requests signed with an Azure Blob
/// Storage shared key.
/// </summary>
/// <param name="credentials">
/// The <see cref="SharedKeyCredentials"/> used to sign requests.
/// </param>
public BlobConnectionOptions(SharedKeyCredentials credentials)
: base(credentials)
{
}
public static QueueServiceClient GetServiceClient_QueueServiceSas(string queueName, SharedKeyCredentials sharedKeyCredentials = default, SasQueryParameters sasCredentials = default)
=> new QueueServiceClient(
new Uri($"{TestConfigurations.DefaultTargetTenant.QueueServiceEndpoint}?{sasCredentials ?? GetNewQueueServiceSasCredentials(queueName, sharedKeyCredentials ?? GetNewSharedKeyCredentials())}"),
GetOptions <QueueConnectionOptions>());