public async Task <DeviceClient> StartProvisioningAsync()
{
ServicePointManager
.ServerCertificateValidationCallback +=
(sender, cert, chain, sslPolicyErrors) => true;
X509Certificate2 rootCA = LoadCertificate("574D9333C86537BC99070353EF1A8C8C50B0B5AE");
X509Certificate2 certificate = LoadCertificate(_provThumbprint);
var myChain = new X509Certificate2Collection();
myChain.Add(rootCA);
myChain.Add(certificate);
using (var security = new SecurityProviderX509Certificate(certificate, myChain))
using (var transport = new ProvisioningTransportHandlerHttp())
{
Microsoft.Azure.Devices.Provisioning.Client.ProvisioningDeviceClient provClient =
Microsoft.Azure.Devices.Provisioning.Client.ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
var sample = new ProvisioningDeviceClient(provClient, security);
return(sample.ProvisionDeviceAndGetClientAsync().GetAwaiter().GetResult());
}
}
public async Task ProvisioningDeviceClient_RegisterAsyncInvalidServiceCertificateHttp_Fails()
{
using (var transport = new ProvisioningTransportHandlerHttp())
{
var exception = await Assert.ThrowsExceptionAsync <ProvisioningTransportException>(
() => TestInvalidServiceCertificate(transport)).ConfigureAwait(false);
#if NET47 || NET451
Assert.IsInstanceOfType(exception.InnerException.InnerException.InnerException, typeof(AuthenticationException));
#elif NETCOREAPP2_0
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// WinHttpException (0x80072F8F): A security error occurred
Assert.AreEqual(unchecked ((int)0x80072F8F), exception.InnerException.InnerException.HResult);
}
else
{
// CURLE_SSL_CACERT (60): Peer certificate cannot be authenticated with known CA certificates.
Assert.AreEqual(60, exception.InnerException.InnerException.HResult);
}
#else
Assert.IsInstanceOfType(exception.InnerException.InnerException, typeof(AuthenticationException));
#endif
}
}
// 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
}
}
}
}
public async Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice requestProvisionDevice, string password)
{
try
{
DeviceCertificateModel certificateInfo = requestProvisionDevice.DeviceCertificateInformation;
//Load certificate chain
var(deviceCertificate, collectionCertificates) =
LoadCertificateFromPfx(Convert.FromBase64String(certificateInfo.Certificate), password);
//Save certificate in store
if (!await SaveCertificateInStore(deviceCertificate))
{
return(ResultCommand.CreateFailedCommand($"Error while saving User Certificate in Store."));
}
using (var securityProvider = new SecurityProviderX509Certificate(deviceCertificate, collectionCertificates))
{
using (var transport = new ProvisioningTransportHandlerHttp())
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(certificateInfo.DpsInstance, certificateInfo.DpsIdScope, securityProvider, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
DebugHelper.LogError($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
return(ResultCommand.CreateFailedCommand($"Error during registration: {result.Status}, {result.ErrorMessage}"));
}
//Test the connection
if (!await TestDeviceConnection(result.DeviceId, result.AssignedHub, deviceCertificate))
{
return(ResultCommand.CreateFailedCommand($"Error while testing the device connection."));
}
//Persist provision in TPM/HSM
SimulatedDevice.ProvisionDevice(result.AssignedHub, result.DeviceId);
//Provisioned!
SimulatedDevice.IsProvisioned = true;
}
}
if (deviceCertificate != null)
{
deviceCertificate.Dispose();
}
return(ResultCommand.CreateSuccessCommand());
}
catch (Exception e)
{
DebugHelper.LogError($"Error ProvisionDevice: {e.Message}.");
return(ResultCommand.CreateFailedCommand($"Error ProvisionDevice: {e.Message}."));
}
}
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("ProvisioningDeviceClientTpm <IDScope>");
return(1);
}
// Remove if a real TPM is being used.
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(s_registrationID))
// Select one of the available transports:
// To optimize for size, reference only the protocols used by your application.
using (var transport = new ProvisioningTransportHandlerHttp())
// using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.WebSocketOnly))
{
// 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());
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($"\tEndorsement key: {base64EK}");
Console.WriteLine($"\tRegistration ID: {s_registrationID}");
Console.WriteLine($"\tDevice ID: {s_registrationID} (or any other valid DeviceID)");
Console.WriteLine();
Console.WriteLine("Press ENTER once enrollment has been created.");
Console.ReadLine();
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
var sample = new ProvisioningDeviceClientSample(provClient, security);
sample.RunSampleAsync().GetAwaiter().GetResult();
}
// Remove if a real TPM is being used.
Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Stopping TPM simulator.");
SecurityProviderTpmSimulator.StopSimulatorProcess();
return(0);
}
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 ProvisioningDeviceClient_RegisterAsyncInvalidServiceCertificateHttp_Fails()
{
using var transport = new ProvisioningTransportHandlerHttp();
ProvisioningTransportException exception = await Assert.ThrowsExceptionAsync <ProvisioningTransportException>(
() => TestInvalidServiceCertificate(transport)).ConfigureAwait(false);
#if NET472 || NET451
Assert.IsInstanceOfType(exception.InnerException.InnerException.InnerException, typeof(AuthenticationException));
#else
Assert.IsInstanceOfType(exception.InnerException.InnerException, typeof(AuthenticationException));
#endif
}
private async Task <DeviceRegistrationResult> RegisterAsync(SecurityProvider security, CancellationToken token)
{
_Logger.EnteringMethodAzure(nameof(CommunicationContext));
ProvisioningTransportHandler transport = null;
try
{
switch (_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();
}
ProvisioningDeviceClient provisioningClient = ProvisioningDeviceClient.Create(_globalDeviceEndpoint, _azureDeviceParameters.AzureScopeId, security, transport);
_Logger.EnteringMethodAzure(nameof(ProvisioningDeviceClient), nameof(ProvisioningDeviceClient.RegisterAsync));
return(await provisioningClient.RegisterAsync(token));
}
finally
{
_Logger.EnteringMethodAzure(nameof(ProvisioningTransportHandler), nameof(ProvisioningTransportHandler.Dispose));
transport.Dispose();
}
}
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);
}
private async Task <ProvisioningRegistrationStatusType> RunDeviceProvisioning()
{
ProvisioningRegistrationStatusType registrationStatus = ProvisioningRegistrationStatusType.Failed;
string registrationId = Dns.GetHostName().ToLower();
using (var security = new SecurityProviderTpmHsm(registrationId))
using (var transport = new ProvisioningTransportHandlerHttp())
{
Logger.Log($"ProvisioningClient RegisterAsync({registrationId})... ", LoggingLevel.Verbose);
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
try
{
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
Logger.Log($"ProvisioningClient RegisterAsync Result = {result.Status}", LoggingLevel.Verbose);
Logger.Log($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}", LoggingLevel.Information);
if (result.Status == ProvisioningRegistrationStatusType.Assigned)
{
// The symmetric key of the assigned device identity is stored in TPM (this is done in ProvisioningDeviceClient.RegisterAsync()),
// for this use case (DM sample), we will need to store some other connection properties
// such as device Id and IoT Hub hostname in TPM for later use to establish IoTHub connection
try
{
var tpmDevice = new TpmDevice();
await tpmDevice.SetConnectionInfoAsync(-1, result.AssignedHub, result.DeviceId);
}
catch (Exception ex)
{
Logger.Log($"SetConnectionInfoAsync Error: Fail to set service Url in TPM. Exception: {ex.Message}", LoggingLevel.Error);
}
}
registrationStatus = result.Status;
}
catch (Exception ex)
{
Logger.Log($"ProvisioningClient Exception: {ex.Message}", LoggingLevel.Error);
}
}
return(registrationStatus);
}
// Registers a device with the Device Provisioning Service using X509 Certificate Authentication
public async Task RegisterAsync()
{
ProvisioningTransportHandler transport;
switch (_deviceRegistrationOptions.TransportMethod)
{
case TransportCommunicationMethods.Http:
transport = new ProvisioningTransportHandlerHttp();
break;
case TransportCommunicationMethods.Mqtt:
transport = new ProvisioningTransportHandlerMqtt();
break;
case TransportCommunicationMethods.Amqp:
transport = new ProvisioningTransportHandlerAmqp();
break;
default:
throw new Exception("Unknown DPS Transport Method");
}
// Set up a proxy for DPS if specified
if (!String.IsNullOrEmpty(_proxyOptions?.ProxyUri))
{
transport.Proxy = new WebProxy(_proxyOptions.ProxyUri);
}
// Create the provisioning client
var dpsClient = ProvisioningDeviceClient.Create(
_deviceRegistrationOptions.GlobalDeviceEndpoint,
_deviceRegistrationOptions.IdScope,
_securityProvider,
transport
);
// Register the device
_registrationResult = await dpsClient.RegisterAsync();
}
private async Task <bool> ProvisionAsync()
{
var dpsGlobalEndpoint = _appConfigService.DpsGlobalEndpoint;
var dpsIdScope = _appConfigService.DpsIdScope;
var deviceId = _deviceInfoService.GetDeviceId();
var dpsSymetricKey = IoTHelpers.GenerateSymmetricKey(deviceId, _appConfigService.DpsSymetricKey);
using (var security = new SecurityProviderSymmetricKey(deviceId, dpsSymetricKey, dpsSymetricKey))
{
using (var transport = new ProvisioningTransportHandlerHttp())
{
var provisioningClient = ProvisioningDeviceClient.Create(dpsGlobalEndpoint, dpsIdScope, security, transport);
var regResult = await provisioningClient.RegisterAsync();
if (regResult.Status == ProvisioningRegistrationStatusType.Assigned)
{
_appConfigService.AssignedEndPoint = regResult.AssignedHub;
}
return(true);
}
}
}
// Connect to IoT Hub/Central and send a test message
private static async Task ConnectAndSend(DeviceProvisioningProxySettings settings)
{
// Configure DPS Transport Proxy
var transport = new ProvisioningTransportHandlerHttp();
transport.Proxy = new WebProxy(settings.ProxyUri);
// Create DPS Client
var security = new SecurityProviderSymmetricKey(settings.RegistrationId, settings.PrimaryKey, settings.SecondaryKey);
var provisioningClient = ProvisioningDeviceClient.Create(settings.GlobalDeviceEndpoint, settings.IdScope, security, transport);
// Register Device
var registrationResult = await provisioningClient.RegisterAsync().ConfigureAwait(false);
// Configure Device Authentication from result
var auth = new DeviceAuthenticationWithRegistrySymmetricKey(registrationResult.DeviceId, security.GetPrimaryKey());
// Configure IoT Hub/Central Proxy
Http1TransportSettings transportSettings = new Http1TransportSettings();
transportSettings.Proxy = new WebProxy(settings.ProxyUri);
ITransportSettings[] transportSettingsArray = new ITransportSettings[] { transportSettings };
// Connect to IoT Hub/Central and send a message
var messageText = "{ \"test\": \"hello\" }";
var message = new Message(Encoding.UTF8.GetBytes(messageText));
using (var deviceClient = DeviceClient.Create(registrationResult.AssignedHub, auth, transportSettingsArray)) {
try {
await deviceClient.SendEventAsync(message);
Console.WriteLine("Message sent");
} finally {
Console.WriteLine("Done");
}
}
}
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("ProvisioningDeviceClientTpm <IDScope>");
return(1);
}
// 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 hyphens
var culture = new CultureInfo("en-US", false);
string RegistrationId = Dns.GetHostName().ToLower(culture).Select(i => (Char.IsLetterOrDigit(i) || (i == '-'))? i.ToString(culture): "-").ToArray().Aggregate((a, b) => a + b);
#if _USE_TPMSIMULATOR
// Remove if a real TPM is being used.
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
// Select one of the available transports:
// To optimize for size, reference only the protocols used by your application.
using (var transport = new ProvisioningTransportHandlerHttp())
// using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.WebSocketOnly))
{
// 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());
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: {RegistrationId} (or any other valid DeviceID)");
Console.WriteLine();
Console.WriteLine("Press ENTER when ready.");
Console.ReadLine();
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
var sample = new ProvisioningDeviceClientSample(provClient, security);
sample.RunSampleAsync().GetAwaiter().GetResult();
}
return(0);
}
static void Main(string[] args)
{
string askeySN;
string token;
string dpsInfoRaw;
string dpsScopeId;
string dpsCertRaw;
string deviceId;
string certBase64String;
string privateKeyBase64String;
Console.Write("Please Enter \"AskeySN\" of activating device:");
askeySN = Console.ReadLine();
Console.Write("Please Enter \"RegistrationId\" of activating device:");
deviceId = Console.ReadLine();
#if DEBUG
askeySN = "79eaab18-7e02-11ea-bfc0-b06ebfcb46d9";
deviceId = "20200414-001";
#endif
if (askeySN == string.Empty)
{
Console.WriteLine("Not allow AskeySN is Empty");
goto Continue;
}
if (deviceId == string.Empty)
{
Console.WriteLine("Not allow RegistrationId is Empty");
goto Continue;
}
//Get Token First
Console.WriteLine("Get Token Process...");
try
{
token = GetADPSTokenString(ADPS_BaseURL, ADPS_GetTokenRoute, askeySN).GetAwaiter().GetResult();
token = token.Substring(1, token.Length - 2);
}
catch (Exception ex)
{
Console.WriteLine("Get Token Error, " + ex.Message);
goto Continue;
}
Console.WriteLine("Get Token:" + token);
Console.WriteLine("Expire Time 2 mins");
Console.WriteLine("");
Console.WriteLine("Get DPS Info...");
try
{
dpsInfoRaw = GetADPSDPSInfoString(ADPS_BaseURL, ADPS_GetDPSInfoRoute, token).GetAwaiter().GetResult();
dpsScopeId = dpsInfoRaw.Split('\n')[2].Split(':')[1];
}
catch (Exception ex)
{
Console.WriteLine("Get DPS Info Error, " + ex.Message);
goto Continue;
}
Console.WriteLine("DPS Scope ID:" + dpsScopeId);
Console.WriteLine("");
Console.WriteLine("Get Cert Info...");
try
{
dpsCertRaw = GetADPSCertString(ADPS_BaseURL, ADPS_GetCertificateRoute, token, deviceId).GetAwaiter().GetResult();
Console.WriteLine("Cert Info:" + dpsCertRaw);
var CertObject = JObject.Parse(dpsCertRaw);
certBase64String = CertObject["publickey"].ToString();
privateKeyBase64String = CertObject["privatekey"].ToString();
}
catch (Exception ex)
{
Console.WriteLine("Get Cert Error, " + ex.Message);
goto Continue;
}
byte[] pfxByteArray;
Console.WriteLine("");
Console.WriteLine("Process Cert Info...");
try
{
pfxByteArray = GetPfxCertificateByteArray(ref certBase64String, ref privateKeyBase64String);
Console.WriteLine("Process Success");
}
catch (Exception ex)
{
Console.WriteLine("Process Cert Error, " + ex.Message);
goto Continue;
}
Console.WriteLine("");
Console.WriteLine("Active Device...");
try
{
X509Certificate2 certificateActive = new X509Certificate2(pfxByteArray);
using (var transport = new ProvisioningTransportHandlerHttp())
{
var security = new SecurityProviderX509Certificate(certificateActive);
ProvisioningDeviceClient client = ProvisioningDeviceClient.Create(DPSGlobalDeviceEndpoint, dpsScopeId, security, transport);
var result = client.RegisterAsync().ConfigureAwait(false).GetAwaiter().GetResult();
Console.WriteLine("DeviceId:" + result.DeviceId);
Console.WriteLine("AssignedHub:" + result.AssignedHub);
Console.WriteLine("Status:" + result.Status);
Console.WriteLine("Substatus:" + result.Substatus);
//client.RegisterAsync().GetAwaiter(false).GetResult();
security.Dispose();
}
}
catch (Exception ex)
{
Console.WriteLine("Active Device Error, " + ex.Message);
goto Continue;
}
Continue:
Console.ReadKey();
}
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);
}
}
}
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();
}
