private static IAuthenticationMethod GetAuthenticationMethod(DeviceRegistrationResult result, SecurityProvider security)
{
IAuthenticationMethod auth;
if (security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, security as SecurityProviderTpm);
}
else if (security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
return(auth);
}
private Client.IAuthenticationMethod CreateAuthenticationMethodFromSecurityProvider(
SecurityProvider provisioningSecurity,
string deviceId)
{
_verboseLog.WriteLine($"{nameof(CreateAuthenticationMethodFromSecurityProvider)}({deviceId})");
if (provisioningSecurity is SecurityProviderTpm)
{
var security = (SecurityProviderTpm)provisioningSecurity;
var auth = new DeviceAuthenticationWithTpm(deviceId, security);
return(auth);
}
else if (provisioningSecurity is SecurityProviderX509)
{
var security = (SecurityProviderX509)provisioningSecurity;
X509Certificate2 cert = security.GetAuthenticationCertificate();
return(new DeviceAuthenticationWithX509Certificate(deviceId, cert));
}
else if (provisioningSecurity is SecurityProviderSymmetricKey)
{
var security = (SecurityProviderSymmetricKey)provisioningSecurity;
var auth = new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, security.GetPrimaryKey());
return(auth);
}
throw new NotSupportedException($"Unknown provisioningSecurity type.");
}
static async Task Main(string[] args)
{
var invalidIotHubAddress = "invalid.azure.devices.com";
var validGatewayAddress = "localhost";
var deviceId = "valid-device-id";
Console.WriteLine("Connecting to the TPM simulator...");
var tpmDevice = ConnectToTpmSimulator();
var securityProvider = new SecurityProviderTpmHsm(deviceId, tpmDevice);
var authenticationMethod = new DeviceAuthenticationWithTpm(deviceId, securityProvider);
Console.WriteLine("Connecting to invalid IoT Hub address directly...");
using (var deviceClient = DeviceClient.Create(invalidIotHubAddress, authenticationMethod))
{
var cts = new CancellationTokenSource(1000);
try { await deviceClient.OpenAsync(cts.Token); }
catch (Exception ex) { Console.WriteLine($"Swallowed expected exception '{ex.Message}'."); }
finally
{
await deviceClient.CloseAsync();
}
}
Console.WriteLine("Connecting to invalid IoT Hub address via valid gateway...");
using (var deviceClient = DeviceClient.Create(invalidIotHubAddress, validGatewayAddress, authenticationMethod))
{
var cts = new CancellationTokenSource(1000);
await deviceClient.OpenAsync(cts.Token); // This is the call that ultimately triggers the NullReferenceException.
await deviceClient.CloseAsync();
}
}
private async Task <Client.IAuthenticationMethod> CreateAuthenticationMethodFromSecurityClient(
SecurityClient provisioningSecurity,
string deviceId,
string iotHub)
{
_verboseLog.WriteLine($"{nameof(CreateAuthenticationMethodFromSecurityClient)}({deviceId})");
if (provisioningSecurity is SecurityClientHsmTpm)
{
var security = (SecurityClientHsmTpm)provisioningSecurity;
var auth = new DeviceAuthenticationWithTpm(deviceId, security);
// TODO: workaround to populate Token.
await auth.GetTokenAsync(iotHub).ConfigureAwait(false);
return(auth);
}
else if (provisioningSecurity is SecurityClientHsmX509)
{
var security = (SecurityClientHsmX509)provisioningSecurity;
X509Certificate2 cert = security.GetAuthenticationCertificate();
return(new DeviceAuthenticationWithX509Certificate(deviceId, cert));
}
throw new NotSupportedException($"Unknown provisioningSecurity type.");
}
private Client.IAuthenticationMethod CreateAuthenticationMethodFromSecurityProvider(
SecurityProvider provisioningSecurity,
string deviceId)
{
_verboseLog.WriteLine($"{nameof(CreateAuthenticationMethodFromSecurityProvider)}({deviceId})");
Client.IAuthenticationMethod auth;
if (provisioningSecurity is SecurityProviderTpm tpmSecurity)
{
auth = new DeviceAuthenticationWithTpm(deviceId, tpmSecurity);
}
else if (provisioningSecurity is SecurityProviderX509 x509Security)
{
X509Certificate2 cert = x509Security.GetAuthenticationCertificate();
auth = new DeviceAuthenticationWithX509Certificate(deviceId, cert);
}
else if (provisioningSecurity is SecurityProviderSymmetricKey symmetricKeySecurity)
{
auth = new DeviceAuthenticationWithRegistrySymmetricKey(deviceId, symmetricKeySecurity.GetPrimaryKey());
}
else
{
throw new NotSupportedException($"Unknown provisioningSecurity type.");
}
return auth;
}
public async Task RunSampleAsync()
{
try
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
Microsoft.Azure.Devices.Client.IAuthenticationMethod auth;
if (_security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, _security as SecurityProviderTpm);
}
else if (_security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, Microsoft.Azure.Devices.Client.TransportType.Amqp))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Microsoft.Azure.Devices.Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
catch (Exception)
{
throw;
}
}
public static async Task RunSample()
{
// Replace the following type with SecurityClientTpm() to use a real TPM2.0 device.
Console.WriteLine("Starting TPM simulator.");
SecurityClientTpmSimulator.StartSimulatorProcess();
using (var security = new SecurityClientTpmSimulator(RegistrationId))
using (var transport = new ProvisioningTransportHandlerHttp())
{
// Note that the TPM simulator will create a NVChip file containing the simulated TPM state.
Console.WriteLine("Extracting endorsement key.");
string base64EK = Convert.ToBase64String(security.GetEndorsementKey());
Console.WriteLine(
"In your Azure Device Provisioning Service please go to 'Manage enrollments' and select " +
"'Individual Enrollments'. Select 'Add' then fill in the following:");
Console.WriteLine("\tMechanism: TPM");
Console.WriteLine($"\tRegistration ID: {RegistrationId}");
Console.WriteLine($"\tEndorsement key: {base64EK}");
Console.WriteLine("\tDevice ID: iothubtpmdevice1 (or any other valid DeviceID)");
Console.WriteLine();
Console.WriteLine("Press ENTER when ready.");
Console.ReadLine();
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(s_idScope, security, transport);
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync();
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
var auth = new DeviceAuthenticationWithTpm(result.DeviceId, security);
// TODO: Temporary workaround until IoTHub DeviceClient gets Token refresh support.
await auth.GetTokenAsync(result.AssignedHub);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync();
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage")));
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync();
}
}
}
public async Task RunSampleAsync()
{
Console.WriteLine("Initializing security using the local TPM...");
using SecurityProviderTpm security = new SecurityProviderTpmHsm(_parameters.RegistrationId);
Console.WriteLine($"Initializing the device provisioning client...");
using var transport = GetTransportHandler();
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(
_parameters.GlobalDeviceEndpoint,
_parameters.IdScope,
security,
transport);
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 TPM authentication for IoT Hub...");
IAuthenticationMethod auth = new DeviceAuthenticationWithTpm(result.DeviceId, security);
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);
await iotClient.CloseAsync();
Console.WriteLine("Finished.");
}
public async Task <DeviceClient> RunAsync()
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return(null);
}
IAuthenticationMethod auth;
if (_security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, _security as SecurityProviderTpm);
}
else if (_security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp);
return(iotClient);
}
private async Task <DeviceClient> ConnectAsync(string assignedHub, SecurityProvider security, CancellationToken token)
{
_Logger.EnteringMethodAzure(nameof(CommunicationContext));
DeviceClient deviceClient;
try
{
IAuthenticationMethod authenticationMethod;
switch (security)
{
case SecurityProviderTpm tpmSecurity:
authenticationMethod = new DeviceAuthenticationWithTpm(_azureDeviceParameters.AzureDeviceId, tpmSecurity);
break;
case SecurityProviderX509 certificateSecurity:
authenticationMethod = new DeviceAuthenticationWithX509Certificate(_azureDeviceParameters.AzureDeviceId, certificateSecurity.GetAuthenticationCertificate());
break;
case SecurityProviderSymmetricKey symmetricKeySecurity:
authenticationMethod = new DeviceAuthenticationWithRegistrySymmetricKey(_azureDeviceParameters.AzureDeviceId, symmetricKeySecurity.GetPrimaryKey());
break;
default:
_Logger.ProgramFailure(nameof(CommunicationContext), "Specified authentication type is unknown.");
throw new NotSupportedException("Unknown authentication type.");
}
_Logger.StartCreatingClient(nameof(DeviceClient), nameof(DeviceClient.Create), assignedHub, authenticationMethod.ToString(), _azureDeviceParameters.TransportType.ToString());
deviceClient = DeviceClient.Create(assignedHub, authenticationMethod, _azureDeviceParameters.TransportType);
_Logger.EnteringMethodAzure(nameof(DeviceClient), nameof(DeviceClient.OpenAsync));
await deviceClient.OpenAsync(token);
}
catch (Exception ex)
{
_Logger.LogException(nameof(CommunicationContext), ex);
return(null);
}
return(deviceClient);
}
public static async Task <int> Main(string[] args)
{
if (args.Length < 3)
{
Console.WriteLine("ProvisioningDeviceClientSymmetricKey <IDScope> <Secret> <registration>");
return(1);
}
s_idScope = args[0];
string primaryKey = args[1];
string secondaryKey = args[1];
registrationId = args[2];
SecurityProvider _security;
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))
{
_security = security;
ProvisioningDeviceClient _provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, _security, transport);
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return(1);
}
IAuthenticationMethod auth;
if (_security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, (_security as SecurityProviderTpm));
}
else if (_security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
// using (var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transportType))
using (DeviceClient deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
//
DigitalTwinClient digitalTwinClient = new DigitalTwinClient(deviceClient);
if (digitalTwinClient == null)
{
Console.WriteLine("Failed to create DeviceClient!");
return(1);
}
var sample = new DigitalTwinClientSample(digitalTwinClient);
await sample.RunSampleAsync();
Console.WriteLine("Waiting to receive updates from cloud...");
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
return(0);
}
public void Run(IBackgroundTaskInstance taskInstance)
{
DeviceRegistrationResult result;
try
{
bme280Sensor = new BME280(0x76);
}
catch (Exception ex)
{
Debug.WriteLine($"BME280 Initialisation failed:{ex.Message}");
return;
}
try
{
using (var security = new SecurityProviderTpmHsm(RegistrationId))
using (var transport = new ProvisioningTransportHandlerHttp())
{
string base64EK = Convert.ToBase64String(security.GetEndorsementKey());
ProvisioningDeviceClient provClient = ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, IdScope, security, transport);
result = provClient.RegisterAsync().ConfigureAwait(false).GetAwaiter().GetResult();
IAuthenticationMethod auth = new DeviceAuthenticationWithTpm(result.DeviceId, security);
azureIoTHubClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Mqtt);
}
}
catch (Exception ex)
{
Debug.WriteLine($"DeviceClient.Create with TPM info failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient.SetMethodHandlerAsync("Restart", RestartAsync, null);
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device method handler configuration failed:{ex.Message}");
return;
}
try
{
TwinCollection reportedProperties;
reportedProperties = new TwinCollection();
// This is from the OS
reportedProperties["Timezone"] = TimeZoneSettings.CurrentTimeZoneDisplayName;
reportedProperties["OSVersion"] = Environment.OSVersion.VersionString;
reportedProperties["MachineName"] = Environment.MachineName;
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
reportedProperties["ApplicationDisplayName"] = package.DisplayName;
reportedProperties["ApplicationName"] = packageId.Name;
reportedProperties["ApplicationVersion"] = string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}");
// Unique identifier from the hardware
SystemIdentificationInfo systemIdentificationInfo = SystemIdentification.GetSystemIdForPublisher();
using (DataReader reader = DataReader.FromBuffer(systemIdentificationInfo.Id))
{
byte[] bytes = new byte[systemIdentificationInfo.Id.Length];
reader.ReadBytes(bytes);
reportedProperties["SystemId"] = BitConverter.ToString(bytes);
}
azureIoTHubClient.UpdateReportedPropertiesAsync(reportedProperties).Wait();
}
catch (Exception ex)
{
Debug.Print($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
deviceTwin = azureIoTHubClient.GetTwinAsync().Result;
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
if (deviceTwin.Properties.Desired.Contains("TimerDue"))
{
timerDue = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerDue"].ToString());
}
if (deviceTwin.Properties.Desired.Contains("TimerPeriod"))
{
timerPeriod = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerPeriod"].ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine($"Sensor due or period configuration retrieval failed using default:{ex.Message}");
return;
}
bme280InputPollingTimer = new Timer(SensorUpdateTimerCallback, null, timerDue, timerPeriod);
//enable task to continue running in background
backgroundTaskDeferral = taskInstance.GetDeferral();
}
public async Task <bool> Initialize()
{
_logger.LogDebug("Obtaining security provider for the device.");
_security = await Device.AzureDeviceParameters.GetSecurityProviderAsync().ConfigureAwait(false);
switch (Device.AzureDeviceParameters.TransportType)
{
case TransportType.Amqp:
_transport = new ProvisioningTransportHandlerAmqp();
break;
case TransportType.Http1:
_transport = new ProvisioningTransportHandlerHttp();
break;
case TransportType.Amqp_WebSocket_Only:
_transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.WebSocketOnly);
break;
case TransportType.Amqp_Tcp_Only:
_transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly);
break;
case TransportType.Mqtt:
_transport = new ProvisioningTransportHandlerMqtt();
break;
case TransportType.Mqtt_WebSocket_Only:
_transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.WebSocketOnly);
break;
case TransportType.Mqtt_Tcp_Only:
_transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly);
break;
default:
throw new ArgumentOutOfRangeException();
}
var provisioningClient = ProvisioningDeviceClient.Create(
GlobalDeviceEndpoint,
Device.AzureDeviceParameters.AzureScopeId,
_security,
_transport);
_logger?.LogDebug("Provisioning device.");
var provisioningResult = await provisioningClient.RegisterAsync().ConfigureAwait(false);
if (provisioningResult.Status == ProvisioningRegistrationStatusType.Assigned)
{
_logger.LogDebug("Successfully provisioned device. Creating client.");
IAuthenticationMethod auth;
switch (_security)
{
case SecurityProviderTpm tpmSecurity:
auth = new DeviceAuthenticationWithTpm(
Device.AzureDeviceParameters.AzureDeviceId,
tpmSecurity);
break;
case SecurityProviderX509 certificateSecurity:
auth = new DeviceAuthenticationWithX509Certificate(
Device.AzureDeviceParameters.AzureDeviceId,
certificateSecurity.GetAuthenticationCertificate());
break;
case SecurityProviderSymmetricKey symmetricKeySecurity:
auth = new DeviceAuthenticationWithRegistrySymmetricKey(
Device.AzureDeviceParameters.AzureDeviceId,
symmetricKeySecurity.GetPrimaryKey());
break;
default:
_logger.LogError("Specified security provider is unknown.");
throw new NotSupportedException("Unknown authentication type.");
}
_deviceClient = DeviceClient.Create(
provisioningResult.AssignedHub,
auth,
Device.AzureDeviceParameters.TransportType);
await _deviceClient.OpenAsync().ConfigureAwait(false);
Device.DeviceClient = _deviceClient;
return(true);
}
_logger.LogWarning(
$"Failed to provision the device. {provisioningResult.Status} - {provisioningResult.ErrorMessage}. Disposing.");
await DisposeAsync();
return(false);
}
public static async Task RunSample()
{
// DPS registration Id should be unique among enrollments.
// Such registration Id could be from TPM or any other unique identity, such as device serial number
// As an example, we use hostname in this sample as the unique registration Id
// A valid DPS registration Id contains only lower case alphanumeric letters and '-'
string RegistrationId = Dns.GetHostName().ToLower().Select(i => (Char.IsLetterOrDigit(i) || (i == '-'))? i.ToString(): "-").ToArray().Aggregate((a, b) => a + b);
#if _USE_TPMSIMULATOR
Console.WriteLine("Starting TPM simulator.");
SecurityProviderTpmSimulator.StartSimulatorProcess();
// Replace the following type with SecurityProviderTpmHsm() to use a real TPM2.0 device.
using (var security = new SecurityProviderTpmSimulator(RegistrationId))
#else
using (var security = new SecurityProviderTpmHsm(RegistrationId))
#endif
using (var transport = new ProvisioningTransportHandlerHttp())
// using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
// Note that the TPM simulator will create an NVChip file containing the simulated TPM state.
Console.WriteLine("Extracting endorsement key.");
string base64EK = Convert.ToBase64String(security.GetEndorsementKey());
string registrationId = security.GetRegistrationID();
Console.WriteLine(
"In your Azure Device Provisioning Service please go to 'Manage enrollments' and select " +
"'Individual Enrollments'. Select 'Add' then fill in the following:");
Console.WriteLine("\tMechanism: TPM");
Console.WriteLine($"\tRegistration ID: {registrationId}");
Console.WriteLine($"\tEndorsement key: {base64EK}");
Console.WriteLine();
Console.WriteLine("Press ENTER when ready.");
Console.ReadLine();
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
var auth = new DeviceAuthenticationWithTpm(result.DeviceId, security);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Http1))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
}
