// This method receives the the provisioning device client and security
// instances created earlier.
private static async Task <DeviceClient> ProvisionDevice(
ProvisioningDeviceClient provisioningDeviceClient,
SecurityProviderSymmetricKey security)
{
// The provisioningDeviceClient.RegisterAsync()
// is called, which returns a DeviceRegistrationResult instance.
// This result contains a number of properties including the DeviceId,
// AssignedHub and the Status.
var result = await provisioningDeviceClient
.RegisterAsync()
.ConfigureAwait(false);
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
// The method then checks to ensure that the provisioning status has
// been set and throws an exception if the device is not Assigned.
// Other possible results here include Unassigned, Assigning,
// Failed and Disabled.
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
// The DeviceAuthenticationWithRegistrySymmetricKey class simplifies
// the creation of an IoT Hub connection string using the device
// ID and the Primary Symmetric Key
var auth = new DeviceAuthenticationWithRegistrySymmetricKey(
result.DeviceId,
security.GetPrimaryKey());
// Finally, a DeviceClient instance is returned that is connected
// to the desired IoT Hub, using the authentication created above,
// and using the AMQP protocol.
return(DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp));
}
static async Task Main(string[] args)
{
var securityProvider = new SecurityProviderSymmetricKey("{registrationId}", "{primaryKey}", "{secondaryKey}");
var provisioningClient = ProvisioningDeviceClient.Create("global.azure-devices-provisioning.net", "{IdScope}", securityProvider, new ProvisioningTransportHandlerMqtt(Microsoft.Azure.Devices.Shared.TransportFallbackType.TcpWithWebSocketFallback));
var result = await provisioningClient.RegisterAsync();
Console.WriteLine($"HostName='{result.AssignedHub}';DeviceId='{result.DeviceId}';SharedAccessKey='{"{primaryKey}"}';");
}
// INSERT Main method below here
public static async Task Main(string[] args)
{
using (var security = new SecurityProviderSymmetricKey(registrationId,
individualEnrollmentPrimaryKey,
individualEnrollmentSecondaryKey))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, dpsIdScope, security, transport);
using (deviceClient = await ProvisionDevice(provClient, security))
{
await deviceClient.OpenAsync().ConfigureAwait(false);
// INSERT Setup OnDesiredPropertyChanged Event Handling below here
await deviceClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false);
// INSERT Load Device Twin Properties below here
var twin = await deviceClient.GetTwinAsync().ConfigureAwait(false);
await OnDesiredPropertyChanged(twin.Properties.Desired, null);
// Start reading and sending device telemetry
Console.WriteLine("Start reading and sending device telemetry...");
await SendDeviceToCloudMessagesAsync();
await deviceClient.CloseAsync().ConfigureAwait(false);
}
}
}
private static async Task RegisterDevice(string deviceRegistrationId)
{
// using symmetric keys
using var securityProvider = new SecurityProviderSymmetricKey(
registrationId: deviceRegistrationId,
primaryKey: ComputeKeyHash(enrollmentGroupPrimaryKey, deviceRegistrationId),
secondaryKey: ComputeKeyHash(enrollmentGroupSecondaryKey, deviceRegistrationId));
// Amqp transport
using var transportHandler = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly);
// set up provisioning client for given device
var provisioningDeviceClient = ProvisioningDeviceClient.Create(
globalDeviceEndpoint: dpsGlobalDeviceEndpoint,
idScope: dpsIdScope,
securityProvider: securityProvider,
transport: transportHandler);
// register device
var deviceRegistrationResult = await provisioningDeviceClient.RegisterAsync();
Console.WriteLine($" Device registration result: {deviceRegistrationResult.Status}");
if (!string.IsNullOrEmpty(deviceRegistrationResult.AssignedHub))
{
Console.WriteLine($" Assigned to hub '{deviceRegistrationResult.AssignedHub}'");
}
Console.WriteLine();
}
// https://github.com/Azure-Samples/azure-iot-samples-csharp/blob/master/provisioning/Samples/device/SymmetricKeySample/Program.cs
// Azure IoT Central Client
static async Task Main(string[] args)
{
IAuthenticationMethod auth;
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey))
using (var transport = new ProvisioningTransportHandlerHttp())
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, idScope, security, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (security as SecurityProviderSymmetricKey).GetPrimaryKey());
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt))
{
while (true)
{
if (_temperature.IsAvailable)
{
try
{
Console.WriteLine($"The CPU temperature is {Math.Round(_temperature.Temperature.Celsius, 2)}");
await SendMsgIotHub(iotClient, _temperature.Temperature.Celsius);
}
catch (Exception ex)
{
Console.WriteLine("exception msg: " + ex.Message);
}
}
Thread.Sleep(10000); // sleep for 10 seconds
}
}
}
}
private async Task <bool> Init()
{
try
{
using (var security = new SecurityProviderSymmetricKey(_deviceID, _primaryKey, null))
{
DeviceRegistrationResult result = await RegisterDeviceAsync(security);
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
_logger.LogInformation("{time} - Failed to register device", DateTimeOffset.Now);
return(false);
}
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (security as SecurityProviderSymmetricKey).GetPrimaryKey());
_deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt);
}
await SendDevicePropertiesAsync();
}
catch (Exception ex)
{
_logger.LogError($"{DateTimeOffset.Now} - Error:{ex.Message}");
return(false);
}
return(true);
}
public DeviceAuthenticationSymmetricKeyFactory(
SecurityProvider securityProvider,
IDeviceRegistrationProvider deviceRegistrationProvider
)
{
_securityProvider = (SecurityProviderSymmetricKey)securityProvider;
_deviceRegistrationProvider = deviceRegistrationProvider;
}
public async Task RunSampleAsync()
{
// When registering with a symmetric key using a group enrollment, the provided key will not
// work for a specific device, rather it must be computed based on two values: the group enrollment
// key and the desired device Id.
if (_parameters.EnrollmentType == EnrollmentType.Group)
{
_parameters.PrimaryKey = ComputeDerivedSymmetricKey(_parameters.PrimaryKey, _parameters.Id);
}
Console.WriteLine($"Initializing the device provisioning client...");
// For individual enrollments, the first parameter must be the registration Id, where in the enrollment
// the device Id is already chosen. However, for group enrollments the device Id can be requested by
// the device, as long as the key has been computed using that value.
// Also, the secondary could could be included, but was left out for the simplicity of this sample.
using var security = new SecurityProviderSymmetricKey(
_parameters.Id,
_parameters.PrimaryKey,
null);
using var transportHandler = GetTransportHandler();
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
_parameters.GlobalDeviceEndpoint,
_parameters.IdScope,
security,
transportHandler);
Console.WriteLine($"Initialized for registration Id {security.GetRegistrationID()}.");
Console.WriteLine("Registering with the device provisioning service...");
DeviceRegistrationResult result = await provClient.RegisterAsync();
Console.WriteLine($"Registration status: {result.Status}.");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine($"Registration status did not assign a hub, so exiting this sample.");
return;
}
Console.WriteLine($"Device {result.DeviceId} registered to {result.AssignedHub}.");
Console.WriteLine("Creating symmetric key authentication for IoT Hub...");
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(
result.DeviceId,
security.GetPrimaryKey());
Console.WriteLine($"Testing the provisioned device with IoT Hub...");
using DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, _parameters.TransportType);
Console.WriteLine("Sending a telemetry message...");
using var message = new Message(Encoding.UTF8.GetBytes("TestMessage"));
await iotClient.SendEventAsync(message);
Console.WriteLine("Finished.");
}
public static async Task RunTest(string scopeId, string sasToken, string deviceId, string dpsEndpoint)
{
Console.WriteLine("Starting DPS client tests.");
int successes = 0;
int failures = 0;
var security = new SecurityProviderSymmetricKey(deviceId, sasToken, null);
var transportHandlers = new List <(ProvisioningTransportHandler, string)>();
transportHandlers.Add((new ProvisioningTransportHandlerHttp(), "default"));
foreach (var transportFallbackType in _transportFallbackTypes)
{
transportHandlers.Add((new ProvisioningTransportHandlerAmqp(transportFallbackType), transportFallbackType.ToString()));
transportHandlers.Add((new ProvisioningTransportHandlerMqtt(transportFallbackType), transportFallbackType.ToString()));
}
foreach ((ProvisioningTransportHandler, string)transportHandler in transportHandlers)
{
try
{
Console.WriteLine($"Registering with {transportHandler.Item1.GetType().Name}/{transportHandler.Item2}");
var provClient = ProvisioningDeviceClient.Create(
dpsEndpoint,
scopeId,
security,
transportHandler.Item1);
DeviceRegistrationResult provResult = await provClient.RegisterAsync().ConfigureAwait(false);
if (provResult.Status != ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine($"Failed to connect due to {provResult.ErrorCode}: {provResult.ErrorMessage}.");
continue;
}
Console.WriteLine("Succeeded.\n");
successes++;
}
catch (Exception ex)
{
// Print all the relevant reasons for failing, without printing out the entire exception information
var reason = new StringBuilder();
Exception next = ex;
do
{
reason.AppendFormat($" - {next.GetType()}: {next.Message}\n");
next = next.InnerException;
}while (next != null);
Console.WriteLine($"Failed for {transportHandler} due to:\n{reason}");
failures++;
}
}
Console.WriteLine($"DPS client tests finished with {successes} successes and {failures} failures.");
}
public SecurityProvider Create()
{
var securityProvider = new SecurityProviderSymmetricKey(
_options.RegistrationId,
_options.PrimaryKey,
_options.SecondaryKey
);
return(securityProvider);
}
//Provision the Device
static void ProvisionDevice()
{
Console.WriteLine("Provisioning process starting..");
Console.WriteLine("Fetching secrets..");
var secrets = ReadSecrets();
if (secrets == null)
{
Console.WriteLine("No secrets found!");
return;
}
Console.WriteLine("Secrets found!");
string dpsServiceEndpoint = secrets.serviceEndpoint;
string idScope = secrets.idScope;
string registrationId = secrets.registrationId;
string primaryDeviceKey = secrets.primaryDerivedKey;
string secondaryDeviceKey = secrets.secondaryDerivedKey;
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryDeviceKey, secondaryDeviceKey))
{
// Select one of the available transports:
// To optimize for size, reference only the protocols used by your application.
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerHttp())
// using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.WebSocketOnly))
{
try
{
Console.WriteLine("Creating provisioning client");
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(dpsServiceEndpoint, idScope, security, transport);
Console.WriteLine("Starting attestation..");
DeviceRegistrationResult registrationResult = provClient.RegisterAsync().GetAwaiter().GetResult();
Console.WriteLine("Device successfully provisioned");
Console.WriteLine("Storing primary and secondary connection strings in settings file!");
Console.WriteLine("Primary Connection string: Hostname={0};DeviceId={1};SharedAccessKey={2}", registrationResult.AssignedHub, registrationId, primaryDeviceKey);
Console.WriteLine("Secondary Connection string: Hostname={0};DeviceId={1};SharedAccessKey={2}", registrationResult.AssignedHub, registrationId, secondaryDeviceKey);
string primaryConnectionString = "Hostname=" + registrationResult.AssignedHub + ";DeviceId=" + registrationResult.DeviceId + ";SharedAccessKey=" + primaryDeviceKey;
string secondaryConnectionString = "Hostname=" + registrationResult.AssignedHub + ";DeviceId=" + registrationResult.DeviceId + ";SharedAccessKey=" + secondaryDeviceKey;
WriteSettings(primaryConnectionString, secondaryConnectionString);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ": " + ex.InnerException.Message);
}
}
}
}
static async Task <DeviceClient> DeviceRegistration(string applicationId, string deviceId, int port)
{
string deviceKey;
// See if AzureIoT hub connections string has been configured
string connectionString = ApplicationConfiguration.ConnectionStringResolve(applicationId, port);
if (!String.IsNullOrEmpty(connectionString))
{
return(DeviceClient.CreateFromConnectionString(connectionString, deviceId));
}
// See if Azure DPS has been configured
using (var hmac = new HMACSHA256(Convert.FromBase64String(ApplicationConfiguration.DpsEnrollmentGroupSymmetricKeyResolve(applicationId, port))))
{
deviceKey = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(deviceId)));
}
using (var securityProvider = new SecurityProviderSymmetricKey(deviceId, deviceKey, null))
{
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(ApplicationConfiguration.DpsGlobaDeviceEndpointResolve(),
ApplicationConfiguration.DpsIdScopeResolve(applicationId, port),
securityProvider,
transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new ApplicationException($"DevID:{deviceId} Status:{result.Status} RegisterAsync failed");
}
IAuthenticationMethod authentication = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (securityProvider as SecurityProviderSymmetricKey).GetPrimaryKey());
return(DeviceClient.Create(result.AssignedHub,
authentication,
new ITransportSettings[]
{
new AmqpTransportSettings(TransportType.Amqp_Tcp_Only)
{
PrefetchCount = 0,
AmqpConnectionPoolSettings = new AmqpConnectionPoolSettings()
{
Pooling = true,
}
}
}
));
}
}
}
private static string ProvisionDevice(string scope, string deviceId, string primaryKey)
{
Console.Write("Provisioning device...");
using var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly);
var security = new SecurityProviderSymmetricKey(deviceId, primaryKey, null);
var provClient = ProvisioningDeviceClient.Create(GlobalProvisionEndPoint, scope, security, transport);
var result = provClient.RegisterAsync().GetAwaiter().GetResult();
Console.WriteLine(" successfully provisioned");
return(result.AssignedHub);
}
public static int Main(string[] args)
{
if (string.IsNullOrWhiteSpace(s_idScope) && (args.Length > 0))
{
s_idScope = args[0];
}
if (string.IsNullOrWhiteSpace(s_idScope))
{
Console.WriteLine("ProvisioningDeviceClientSymmetricKey <IDScope>");
return(1);
}
string primaryKey = "";
string secondaryKey = "";
if (!String.IsNullOrEmpty(registrationId) && !String.IsNullOrEmpty(enrollmentGroupPrimaryKey) && !String.IsNullOrEmpty(enrollmentGroupSecondaryKey))
{
//Group enrollment flow, the primary and secondary keys are derived from the enrollment group keys and from the desired registration id
primaryKey = ComputeDerivedSymmetricKey(Convert.FromBase64String(enrollmentGroupPrimaryKey), registrationId);
secondaryKey = ComputeDerivedSymmetricKey(Convert.FromBase64String(enrollmentGroupSecondaryKey), registrationId);
}
else if (!String.IsNullOrEmpty(registrationId) && !String.IsNullOrEmpty(individualEnrollmentPrimaryKey) && !String.IsNullOrEmpty(individualEnrollmentSecondaryKey))
{
//Individual enrollment flow, the primary and secondary keys are the same as the individual enrollment keys
primaryKey = individualEnrollmentPrimaryKey;
secondaryKey = individualEnrollmentSecondaryKey;
}
else
{
Console.WriteLine("Invalid configuration provided, must provide group enrollment keys or individual enrollment keys");
return(-1);
}
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey))
// Select one of the available transports:
// To optimize for size, reference only the protocols used by your application.
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerHttp())
// using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.WebSocketOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
var sample = new ProvisioningDeviceClientSample(provClient, security);
sample.RunSampleAsync().GetAwaiter().GetResult();
}
Console.WriteLine("Enter any key to exit");
Console.ReadLine();
return(0);
}
public async Task <Microsoft.Azure.Devices.Client.DeviceClient> ProvisionAsync <DeviceClient>(DataStorage storage)
{
var connStringContent = storage.Read("ConnectionString");
DevicePortalInfoModel model = JsonConvert.DeserializeObject <DevicePortalInfoModel>(connStringContent);
string scope = model.Device.ID_Scope;
string primaryKey = model.Device.PrimaryKey;
string secondaryKey = model.Device.SecondaryKey;
string registrationId = model.Device.RegistrationId;
_sendTelemetry = false;
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey))
{
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
_sendTelemetry = false;
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, scope, security, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return(null);
}
Console.WriteLine($"Provisioninged device : {result.DeviceId} at {result.AssignedHub}");
var client = Microsoft.Azure.Devices.Client.DeviceClient.Create(result.AssignedHub, model.Auth, TransportType.Amqp);
client.SetMethodHandlerAsync("Reprovision", ReprovisionHandler, null).GetAwaiter().GetResult();
client.SetDesiredPropertyUpdateCallbackAsync(DesiredPropertyUpdated, null).GetAwaiter().GetResult();
// TODO:Save new connection information
var auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, security.GetPrimaryKey());
var host = result.AssignedHub;
var builder = IotHubConnectionStringBuilder.Create(host, auth);
var device = new DevicePortalInfoModel
{
Host = result.AssignedHub,
Auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, security.GetPrimaryKey()),
Device = new DeviceModel {
ID_Scope = scope,
PrimaryKey = security.GetPrimaryKey(),
SecondaryKey = security.GetSecondaryKey(),
RegistrationId = result.RegistrationId,
DeviceId = result.DeviceId
},
ConnectionString = builder.ToString()
};
_storage.Write(DataStorage.DeviceConnectionString, JsonConvert.SerializeObject(device));
return(client);
}
}
}
// Provision a device via DPS, by sending the PnP model Id as DPS payload.
private static async Task <DeviceRegistrationResult> ProvisionDeviceAsync(Parameters parameters, CancellationToken cancellationToken)
{
SecurityProvider symmetricKeyProvider = new SecurityProviderSymmetricKey(parameters.DeviceId, parameters.DeviceSymmetricKey, null);
ProvisioningTransportHandler mqttTransportHandler = new ProvisioningTransportHandlerMqtt();
var pdc = ProvisioningDeviceClient.Create(parameters.DpsEndpoint, parameters.DpsIdScope, symmetricKeyProvider, mqttTransportHandler);
var pnpPayload = new ProvisioningRegistrationAdditionalData
{
JsonData = $"{{ \"modelId\": \"{ModelId}\" }}",
};
return(await pdc.RegisterAsync(pnpPayload, cancellationToken));
}
public static async Task <DeviceRegistrationResult> RegisterDeviceAsync(SecurityProviderSymmetricKey security, Device dev)
{
// Console.WriteLine("Register device...");
using var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly);
var provClient =
ProvisioningDeviceClient.Create(dev.IoTGlobalDeviceEndpoint, dev.IoTDeviceScopeId, security, transport);
// Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
// Console.Write("ProvisioningClient RegisterAsync...");
var result = await provClient.RegisterAsync();
// Console.WriteLine($"ProvisioningClient Stauts: {result.Status}, AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
return(result);
}
static async Task Main(string[] args)
{
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey))
using (var transport = new ProvisioningTransportHandlerMqtt())
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, idScope, security, transport);
var pnpPayload = new ProvisioningRegistrationAdditionalData
{
JsonData = $"{{ \"modelId\": \"{ModelId}\" }}",
};
DeviceRegistrationResult result = await provClient.RegisterAsync(pnpPayload);
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (security as SecurityProviderSymmetricKey).GetPrimaryKey());
using (iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt))
{
await iotClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChangedAsync, null).ConfigureAwait(false); // callback for Device Twin updates
await DeviceTwinGetInitialState(iotClient); // Get current cloud state of the device twin
while (true)
{
if (_temperature.IsAvailable)
{
try
{
temperature = Math.Round(_temperature.Temperature.DegreesCelsius, 2);
Console.WriteLine($"The CPU temperature is {temperature}");
await SendMsgIotHub(iotClient, temperature);
roomState = (int)temperature > targetTemperature ? RoomAction.Cooling : (int)temperature < targetTemperature ? RoomAction.Heating : RoomAction.Green;
await UpdateRoomAction(roomState);
if (temperature > maxTemperature)
{
maxTemperature = temperature;
await UpdateDeviceTwin("maxTempSinceLastReboot", maxTemperature);
}
}
catch (Exception ex)
{
Console.WriteLine("exception msg: " + ex.Message);
}
}
Thread.Sleep(2000); // sleep for 2 seconds
}
}
}
}
public static DeviceClient CreateDeviceClient(Device dev)
{
using var security = new SecurityProviderSymmetricKey(dev.IoTDeviceId, dev.IoTDevicePrimaryKey, null);
var result = RegisterDeviceAsync(security, dev).GetAwaiter().GetResult();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine("Failed to register device");
return(null);
}
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, security.GetPrimaryKey());
return(DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt));
}
static void Main(string[] args)
{
rand = new Random();
colorMessage($"Starting {truckIdentification}", ConsoleColor.Yellow);
currentLat = baseLat;
currentLon = baseLon;
// Connect to Azure Maps.
azureMapsServices = new AzureMapsServices(AzureMapsKey);
try
{
using (var security = new SecurityProviderSymmetricKey(DeviceID, PrimaryKey, null))
{
DeviceRegistrationResult result = RegisterDeviceAsync(security).GetAwaiter().GetResult();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine("Failed to register device");
return;
}
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (security as SecurityProviderSymmetricKey).GetPrimaryKey());
s_deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt);
}
greenMessage("Device successfully connected to Azure IoT Central");
SendDevicePropertiesAsync().GetAwaiter().GetResult();
Console.Write("Register settings changed handler...");
s_deviceClient.SetDesiredPropertyUpdateCallbackAsync(HandleSettingChanged, null).GetAwaiter().GetResult();
Console.WriteLine("Done");
cts = new CancellationTokenSource();
// Create a handler for the direct method calls.
s_deviceClient.SetMethodHandlerAsync("GoToCustomer", CmdGoToCustomer, null).Wait();
s_deviceClient.SetMethodHandlerAsync("Recall", CmdRecall, null).Wait();
SendTruckTelemetryAsync(rand, cts.Token);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
cts.Cancel();
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine(ex.Message);
}
}
static async Task <EnrollmentDetails> EnrollDeviceAsync(string deviceId)
{
//we need a couple of parameters to start. How you get these values is up to you.
//What is important is that the enrollment keys (Primary & secondary) should
//be considered as secrets and stored as such. Just like certificate, it
//will be the responsibility of Bell to deploy these credentials to the device
//and keep them up to date
string dpsEndpoint = Environment.GetEnvironmentVariable("dpsEndpoint") ?? "global.azure-devices-provisioning.net";
string dpsIdScope = Environment.GetEnvironmentVariable("idscope") ?? "{Insert ID Scope Here}";
string enrollmentKeyPrimary = Environment.GetEnvironmentVariable("enrollmentKeyPrimary") ?? "{Insert Primary Enrollment Key Here}";
string enrollmentKeySecondary = Environment.GetEnvironmentVariable("enrollmentKeySecondary") ?? "{Insert Seconday Enrollment Key Here}";
//first, we need to create a device specific attestation key, derived from
//the enrollment key. These attestation keys will ultimately become the credentials
//for the device into Iot Hub when provisioned. They also serve as a way for
//the DPS service to validate the device is trusted, without actually having to
//send the enrollment group key across the network
string attestationKeyPrimary = ComputeDeviceAttestationKey(enrollmentKeyPrimary, deviceId);
string attestationKeySecondary = ComputeDeviceAttestationKey(enrollmentKeySecondary, deviceId);
//now, we can attempt to register this device with DPS
using (SecurityProviderSymmetricKey keyProvider = new SecurityProviderSymmetricKey(deviceId, attestationKeyPrimary, attestationKeySecondary))
{
using (ProvisioningTransportHandlerAmqp transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provisioningClient = ProvisioningDeviceClient.Create(dpsEndpoint, dpsIdScope, keyProvider, transport);
DeviceRegistrationResult result = await provisioningClient.RegisterAsync();
switch (result.Status)
{
case ProvisioningRegistrationStatusType.Assigned:
//device was successfully assigned by dps to an Iot Hub
return(new EnrollmentDetails()
{
DeviceId = deviceId,
IotHubEndpoint = result.AssignedHub,
Authentication = new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, attestationKeyPrimary)
});
case ProvisioningRegistrationStatusType.Assigning:
case ProvisioningRegistrationStatusType.Disabled:
case ProvisioningRegistrationStatusType.Failed:
case ProvisioningRegistrationStatusType.Unassigned:
default:
return(null);
}
}
}
}
public ProvisioningDeviceClientWrapper(string s_idScope, string registrationId, string enrollmentGroupPrimaryKey, string enrollmentGroupSecondaryKey)
{
//Group enrollment flow, the primary and secondary keys are derived from the enrollment group keys and from the desired registration id
string primaryKey = ComputeDerivedSymmetricKey(Convert.FromBase64String(enrollmentGroupPrimaryKey), registrationId);
string secondaryKey = ComputeDerivedSymmetricKey(Convert.FromBase64String(enrollmentGroupSecondaryKey), registrationId);
SecurityProviderSymmetricKey security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey);
ProvisioningTransportHandlerAmqp transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly);
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
_provClient = provClient;
_security = security;
}
private async Task <DeviceRegistrationResult> RegisterDeviceAsync(SecurityProviderSymmetricKey security)
{
_logger.LogInformation("{time} - Register device...", DateTimeOffset.Now);
using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(_globalDeviceEndpoint, _scopeID, security, transport);
_logger.LogInformation($"{DateTimeOffset.Now} - RegistrationID = {security.GetRegistrationID()}");
DeviceRegistrationResult result = await provClient.RegisterAsync();
_logger.LogInformation($"{DateTimeOffset.Now} - ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
return(result);
}
}
public static async Task <DeviceRegistrationResult> RegisterToIoTHubAsync(string primaryKey, string secondKey, string registeredId)
{
using var security = new SecurityProviderSymmetricKey(registeredId, primaryKey, secondKey);
using var transport = new ProvisioningTransportHandlerHttp();
var provClient = ProvisioningDeviceClient.Create(
GlobalDeviceEndpoint,
IdScope,
security,
transport);
// register into IoTHub
var result = await provClient.RegisterAsync();
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
return(result);
}
public async Task <IoTHubDeviceClient> ProvisionDeviceAsync()
{
string connectionKey;
IoTHubDeviceClient iotHubClient = null;
Console.WriteLine("Provisioning...");
if (!String.IsNullOrEmpty(_deviceId) && !String.IsNullOrEmpty(s_sasKey) && !String.IsNullOrEmpty(s_idScope))
{
connectionKey = GenerateSymmetricKey();
Console.WriteLine($"Connection Key : {connectionKey}");
using (var securityProvider = new SecurityProviderSymmetricKey(_deviceId, connectionKey, null))
using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
{
_provClient = ProvisioningDeviceClient.Create(s_global_endpoint, s_idScope, securityProvider, transport);
// Sanity check
Console.WriteLine($"Device ID : {securityProvider.GetRegistrationID()}");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
if (result.Status == ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine($"Provisioned : {result.Status}");
Console.WriteLine($" Device ID : {result.DeviceId}");
Console.WriteLine($" IoT Hub : {result.AssignedHub}");
IAuthenticationMethod authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, securityProvider.GetPrimaryKey());
iotHubClient = new IoTHubDeviceClient(result.AssignedHub, authenticationMethod);
}
else
{
Console.WriteLine($"Err : Provisioning Failed {result.Status}");
}
}
}
else
{
Console.WriteLine("Please set following Environment Variables");
Console.WriteLine("DPS_IDSCOPE : ID Scope");
Console.WriteLine("SAS_KEY : SAS Key");
}
return(iotHubClient);
}
public static int Main(string[] args)
{
if (string.IsNullOrWhiteSpace(dpsIdScope) && (args.Length > 0))
{
dpsIdScope = args[0];
}
if (string.IsNullOrWhiteSpace(dpsIdScope))
{
Console.WriteLine("ProvisioningDeviceClientSymmetricKey <IDScope>");
return(1);
}
string primaryKey = string.Empty;
string secondaryKey = string.Empty;
if (!String.IsNullOrEmpty(registrationId) && !String.IsNullOrEmpty(individualEnrollmentPrimaryKey) && !String.IsNullOrEmpty(individualEnrollmentSecondaryKey))
{
//Individual enrollment flow, the primary and secondary keys are the same as the individual enrollment keys
primaryKey = individualEnrollmentPrimaryKey;
secondaryKey = individualEnrollmentSecondaryKey;
}
else
{
Console.WriteLine("Invalid configuration provided, must provide individual enrollment keys");
return(-1);
}
using (var security = new SecurityProviderSymmetricKey(registrationId, primaryKey, secondaryKey))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, dpsIdScope, security, transport);
var provisioningDeviceLogic = new ProvisioningDeviceLogic(provClient, security);
provisioningDeviceLogic.RunAsync().GetAwaiter().GetResult();
}
return(0);
}
static async Task DeviceRegistration(string globalDeviceEndpoint, string IdScope, string enrollmentGroupSymmetricKey, string registrationId, string applicationId)
{
DeviceClient deviceClient;
try
{
string deviceKey = ComputeDerivedSymmetricKey(Convert.FromBase64String(enrollmentGroupSymmetricKey), registrationId);
using (var securityProvider = new SecurityProviderSymmetricKey(registrationId, deviceKey, null))
{
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(globalDeviceEndpoint, IdScope, securityProvider, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new ApplicationException($"DevID:{registrationId} AppID:{applicationId} Status:{result.Status} RegisterAsync failed");
}
Log.LogInformation("DevID:{registrationId} AppID:{applicationId} Assigned IoTHub:{assignedHub}", registrationId, applicationId, result.AssignedHub);
IAuthenticationMethod authentication = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (securityProvider as SecurityProviderSymmetricKey).GetPrimaryKey());
deviceClient = DeviceClient.Create(result.AssignedHub, authentication, TransportType.Amqp);
if (!DeviceClients.TryUpdate(registrationId, deviceClient, null))
{
Log.LogWarning("DevID:{registrationID} AppID:{applicationId} Device Registration TryUpdate failed", registrationId, applicationId);
}
}
}
}
catch (Exception ex)
{
if (!DeviceClients.TryRemove(registrationId, out deviceClient))
{
Log.LogWarning("DevID:{registrationID} AppID:{applicationId} Device Registration TryRemove failed", registrationId, applicationId);
}
Log.LogError(ex, "DevID:{registrationID} AppID:{applicationId} Device Registration failed", registrationId, applicationId);
throw;
}
}
public static async Task <DeviceRegistrationResult> RegisterDeviceAsync(SecurityProviderSymmetricKey security)
{
Console.WriteLine("Register device...");
using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, ScopeID, security, transport);
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
Console.Write("ProvisioningClient RegisterAsync...");
DeviceRegistrationResult result = await provClient.RegisterAsync();
Console.WriteLine($"{result.Status}");
return(result);
}
}
private static async Task <DeviceRegistrationResult> RegisterDevice()
{
try
{
ConsoleWriteLine($"Will register device {deviceId}...", ConsoleColor.White);
// using symmetric keys
using var securityProvider = new SecurityProviderSymmetricKey(
registrationId: deviceId,
primaryKey: devicePrimaryKey,
secondaryKey: null);
using var transportHandler = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly);
// set up provisioning client for given device
var provisioningDeviceClient = ProvisioningDeviceClient.Create(
globalDeviceEndpoint: provisioningGlobalDeviceEndpoint,
idScope: provisioningIdScope,
securityProvider: securityProvider,
transport: transportHandler);
// register device
var deviceRegistrationResult = await provisioningDeviceClient.RegisterAsync();
ConsoleWriteLine($"Device {deviceId} registration result: {deviceRegistrationResult.Status}", ConsoleColor.White);
if (deviceRegistrationResult.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"Failed to register device {deviceId}");
}
ConsoleWriteLine($"Device {deviceId} was assigned to hub '{deviceRegistrationResult.AssignedHub}'", ConsoleColor.White);
ConsoleWriteLine();
return(deviceRegistrationResult);
}
catch (Exception ex)
{
ConsoleWriteLine($"* ERROR * {ex.Message}", ConsoleColor.Red);
}
return(null);
}
internal static async Task <DeviceClient> ProvisionDeviceWithSasKeyAsync(string scopeId, string deviceId, string deviceKey, string modelId, ILogger log)
{
using (var transport = new ProvisioningTransportHandlerMqtt())
{
using (var security = new SecurityProviderSymmetricKey(deviceId, deviceKey, null))
{
DeviceRegistrationResult provResult;
var provClient = ProvisioningDeviceClient.Create("global.azure-devices-provisioning.net", scopeId, security, transport);
if (!string.IsNullOrEmpty(modelId))
{
provResult = await provClient.RegisterAsync(GetProvisionPayload(modelId)).ConfigureAwait(false);
}
else
{
provResult = await provClient.RegisterAsync().ConfigureAwait(false);
}
log.LogInformation($"Provioning Result. Status [{provResult.Status}] SubStatus [{provResult.Substatus}]");
if (provResult.Status == ProvisioningRegistrationStatusType.Assigned)
{
log.LogWarning($"Device {provResult.DeviceId} in Hub {provResult.AssignedHub}");
log.LogInformation($"LastRefresh {provResult.LastUpdatedDateTimeUtc} RegistrationId {provResult.RegistrationId}");
var csBuilder = IotHubConnectionStringBuilder.Create(provResult.AssignedHub, new DeviceAuthenticationWithRegistrySymmetricKey(provResult.DeviceId, security.GetPrimaryKey()));
string connectionString = csBuilder.ToString();
return(await Task.FromResult(
DeviceClient.CreateFromConnectionString(
connectionString, TransportType.Mqtt,
new ClientOptions()
{
ModelId = modelId
})));
}
else
{
string errorMessage = $"Device not provisioned. Message: {provResult.ErrorMessage}";
log.LogError(errorMessage);
throw new IotHubException(errorMessage);
}
}
}
}
