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());
}
}
static void Main(string[] args)
{
string[] certFilePaths = Directory.GetFiles(ConfigurationManager.AppSettings["CertDirectory"], "*.pfx");
string plainTextPassword = ConfigurationManager.AppSettings["SecureString"];
foreach (string certFilePath in certFilePaths)
{
using (X509Certificate2 cert = new X509Certificate2(certFilePath, plainTextPassword, X509KeyStorageFlags.UserKeySet))
{
using (var security = new SecurityProviderX509Certificate(cert))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, IdScope, security, transport);
Console.WriteLine($"Registering device with RegistrationID = {security.GetRegistrationID()}");
DeviceRegistrationResult result = provClient.RegisterAsync().GetAwaiter().GetResult();
Console.WriteLine($"{result.Status}");
Console.WriteLine(
$"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
}
}
}
}
// This Main method is very similar to that used in the earlier lab.
// The two significant changes are the need to load the X.509 certificate
// and then the change to using SecurityProviderX509Certificate as the
// security provider. The remaining code is identical - you should note
// that the device twin property change code is also present.
public static async Task Main(string[] args)
{
X509Certificate2 certificate = LoadProvisioningCertificate();
using (var security = new SecurityProviderX509Certificate(certificate))
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);
// Setup device twin callbacks
await deviceClient
.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null)
.ConfigureAwait(false);
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 void ConnectViaX509(SecureString password, ClientType clientType, TransportType transportType)
{
string certPath = Environment.GetEnvironmentVariable("DEVICE_CERTIFICATE");
if (certPath == null)
{
certPath = ConfigurationManager.AppSettings["DEVICE_CERTIFICATE"];
}
string iotHubUri = Environment.GetEnvironmentVariable("IOT_HUB_URI");
if (iotHubUri == null)
{
iotHubUri = ConfigurationManager.AppSettings["IOT_HUB_URI"];
}
System.Security.Cryptography.X509Certificates.X509Certificate2 myCert = new System.Security.Cryptography.X509Certificates.X509Certificate2(certPath, password);
using (var security = new SecurityProviderX509Certificate(myCert))
{
deviceId = security.GetRegistrationID();
// Device Client Type
switch (clientType)
{
case ClientType.Primary:
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithX509Certificate(security.GetRegistrationID(), myCert), transportType);
break;
case ClientType.Secondary:
secondaryDeviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithX509Certificate(security.GetRegistrationID(), myCert), transportType);
break;
}
}
}
public async Task <DeviceRegistrationResult> RegisterDeviceAsync(
X509Certificate2 deviceCertificate,
X509Certificate2 enrollmentCertificate)
{
var scopeId = Configuration["ScopeId"];
//// The cert from the enrollment group is required for group registrations
//X509Certificate2 enrollmentCertificate = new X509Certificate2("dpsIntermediate1.pfx", "1234");
using (var security = new SecurityProviderX509Certificate(deviceCertificate,
new X509Certificate2Collection(enrollmentCertificate)))
// 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))
{
var client = ProvisioningDeviceClient.Create(
"global.azure-devices-provisioning.net", scopeId, security, transport);
var result = await client.RegisterAsync();
_logger.LogInformation($"DPS client created: {result}");
return(result);
}
}
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("ProvisioningDeviceClientX509 <IDScope>");
return(1);
}
X509Certificate2 certificate = LoadProvisioningCertificate();
using (var security = new SecurityProviderX509Certificate(certificate))
// 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();
}
return(0);
}
protected virtual async Task <DeviceRegistrationResult> RegisterDeviceAsync(
string dpsGlobalDeviceEndpoint,
string dpsIdScope)
{
DeviceRegistrationResult result = null;
using (var security =
new SecurityProviderX509Certificate(
this.HardwareSecurityModel.DeviceLeafCert))
using (var transport =
new ProvisioningTransportHandlerMqtt(
TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(
dpsGlobalDeviceEndpoint,
dpsIdScope,
security,
transport);
result = await provClient.RegisterAsync().ConfigureAwait(false);
}
return(result);
}
// NOTE: For the purposes of this example, the certificatePassword is
// hard coded. In a production device, the password will need to be stored
// in a more secure manner. Additionally, the certificate file (PFX) should
// be stored securely on a production device using a Hardware Security Module.
public static async Task <int> Main(string[] args)
{
var tasks = new List <Task>();
foreach (var fileName in certificateFileNames)
{
X509Certificate2 certificate = LoadProvisioningCertificate(fileName);
using (var security = new SecurityProviderX509Certificate(certificate))
{
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, dpsIdScope, security, transport);
var container = new ContainerDeviceSimulator(provClient, security);
tasks.Add(container.RunAsync());
await Task.Delay(30000); // add a device every 30 seconds
}
}
}
await Task.WhenAll(tasks);
return(0);
}
public static async Task RunSample(X509Certificate2 certificate)
{
using (var security = new SecurityProviderX509Certificate(certificate))
// using (var transport = new ProvisioningTransportHandlerHttp())
//using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
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;
}
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, certificate);
iotClient = DeviceClient.Create(result.AssignedHub, auth);
Console.WriteLine($"Now {deviceID} can start sending messages to assigned IoT Hub: {result.AssignedHub}");
await iotClient.OpenAsync();
SendDeviceToCloudMessagesAsync();
Console.ReadLine();
}
}
public DeviceRegistrationResult RegisterDevice(string deviceId, string password)
{
var cert = deviceManager.ReadPrivateCertificate(deviceId, password);
using (var security = new SecurityProviderX509Certificate(cert))
{
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(configuration.GetValue <string>("DeviceProvisioningEndpoint"), configuration.GetValue <string>("DeviceProvisioningScope"), security, transport);
var result = provClient.RegisterAsync().GetAwaiter().GetResult();
deviceManager.SaveRegistration(new Models.RegistrationInfo
{
AssignedHub = result.AssignedHub,
DeviceId = result.DeviceId,
RegistrationId = result.RegistrationId
});
deviceManager.SavePassword(deviceId, password);
return(result);
}
}
}
public static async Task RunSample(X509Certificate2 certificate)
{
using (var security = new SecurityProviderX509Certificate(certificate))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, 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;
}
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, certificate);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth))
{
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 DeviceAuthenticationX509Factory(
SecurityProvider securityProvider,
IDeviceRegistrationProvider deviceRegistrationProvider
)
{
_securityProvider = (SecurityProviderX509Certificate)securityProvider;
_deviceRegistrationProvider = deviceRegistrationProvider;
}
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}."));
}
}
private static async Task TestInvalidServiceCertificate(ProvisioningTransportHandler transport)
{
using var security =
new SecurityProviderX509Certificate(Configuration.Provisioning.GetIndividualEnrollmentCertificate());
ProvisioningDeviceClient provisioningDeviceClient = ProvisioningDeviceClient.Create(
Configuration.Provisioning.GlobalDeviceEndpointInvalidServiceCertificate,
"0ne00000001",
security,
transport);
await provisioningDeviceClient.RegisterAsync().ConfigureAwait(false);
}
internal static async Task <DeviceClient> ProvisionDeviceWithCertAsync(string scopeId, string X509LocatorString, string modelId, ILogger log)
{
using (var transport = new ProvisioningTransportHandlerMqtt())
{
var cert = X509Loader.GetCertFromConnectionString(X509LocatorString, log);
using (var security = new SecurityProviderX509Certificate(cert))
{
DeviceRegistrationResult provResult;
var provClient = ProvisioningDeviceClient.Create("global.azure-devices-provisioning.net", scopeId, security, transport);
if (!String.IsNullOrEmpty(modelId))
{
provResult = await provClient.RegisterWithModelAsync(modelId, log);
}
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}");
Rido.DeviceClientFactory.Instance.HostName = provResult.AssignedHub;
var csBuilder = IotHubConnectionStringBuilder.Create(provResult.AssignedHub, new DeviceAuthenticationWithX509Certificate(provResult.DeviceId, security.GetAuthenticationCertificate()));
string connectionString = csBuilder.ToString();
DeviceClient client;
if (string.IsNullOrEmpty(modelId))
{
client = DeviceClient.Create(provResult.AssignedHub, new DeviceAuthenticationWithX509Certificate(provResult.DeviceId, security.GetAuthenticationCertificate()), TransportType.Mqtt);
}
else
{
client = DeviceClient.Create(provResult.AssignedHub, new DeviceAuthenticationWithX509Certificate(provResult.DeviceId, security.GetAuthenticationCertificate()), TransportType.Mqtt, new ClientOptions {
ModelId = modelId
});
}
return(client);
}
else
{
string errorMessage = $"Device not provisioned. Message: {provResult.ErrorMessage}";
log.LogError(errorMessage);
throw new IotHubException(errorMessage);
}
}
}
}
/// <summary>
/// Registers device with IoT Hub using Device Provisioning Service
/// </summary>
/// <param name="cert"></param>
/// <param name="s_idScope"></param>
/// <returns></returns>
public async Task <DeviceRegistrationResult> RegisterDevice(X509Certificate2 cert, string s_idScope)
{
using (var security = new SecurityProviderX509Certificate(cert))
// using (var transport = new ProvisioningTransportHandlerHttp())
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
// using (var transport = new ProvisioningTransportHandlerMqtt(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, s_idScope, security, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
return(result);
}
}
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> <registrationID>");
return(1);
}
if (string.IsNullOrWhiteSpace(s_registrationID) && (args.Length > 1))
{
s_registrationID = args[1];
s_certificateFileName = s_registrationID + ".pfx";
}
if (string.IsNullOrWhiteSpace(s_registrationID))
{
Console.WriteLine("ProvisioningDeviceClientSymmetricKey <IDScope> <registrationID>");
return(1);
}
//X509Certificate2 certificate = LoadProvisioningCertificate();
var myCertificate = new X509Certificate2(s_certificateFileName, "1234");
var myChain = new X509Certificate2Collection();
//myChain.Import("azure-iot-test-only.chain.ca.cert.pem");
using (var security = new SecurityProviderX509Certificate(myCertificate, myChain))
// 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();
}
return(0);
}
private void ConnectViaDPSX509(SecureString password, TransportType transportType)
{
string certPath = Environment.GetEnvironmentVariable("DEVICE_CERTIFICATE");
if (certPath == null)
{
certPath = ConfigurationManager.AppSettings["DEVICE_CERTIFICATE"];
}
string scopeId = Environment.GetEnvironmentVariable("DPS_IDSCOPE");
if (scopeId == null)
{
scopeId = ConfigurationManager.AppSettings["DPS_IDSCOPE"];
}
System.Security.Cryptography.X509Certificates.X509Certificate2 myCert =
new System.Security.Cryptography.X509Certificates.X509Certificate2(certPath, password);
using (var security = new SecurityProviderX509Certificate(myCert)) {
using (var transport = new ProvisioningTransportHandlerMqtt(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, scopeId, security, transport);
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
VerifyRegistrationIdFormat(security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = provClient.RegisterAsync().Result;
deviceId = result.DeviceId;
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (security as SecurityProviderX509).GetAuthenticationCertificate());
deviceClient = DeviceClient.Create(result.AssignedHub, auth, transportType);
}
}
}
private async Task TestInvalidServiceCertificate(ProvisioningTransportHandler transport)
{
string certificateSubject = $"E2E_{nameof(ProvisioningCertificateValidationE2ETest)}-{Guid.NewGuid()}";
X509Certificate2Helper.GenerateSelfSignedCertificateFiles(certificateSubject, s_x509CertificatesFolder, Logger);
using X509Certificate2 cert = X509Certificate2Helper.CreateX509Certificate2FromPfxFile(certificateSubject, s_x509CertificatesFolder);
using var security = new SecurityProviderX509Certificate(cert);
var provisioningDeviceClient = ProvisioningDeviceClient.Create(
TestConfiguration.Provisioning.GlobalDeviceEndpointInvalidServiceCertificate,
"0ne00000001",
security,
transport);
await provisioningDeviceClient.RegisterAsync().ConfigureAwait(false);
}
private static async Task Main(string[] args)
{
Console.WriteLine("DPS auto provisioned device");
if (args.Length == 0)
{
Console.WriteLine("Please pass ID Scope as first command line argument");
return;
}
var idScope = args[0];
var certificate = LoadCertificate();
DeviceAuthenticationWithX509Certificate auth;
string iotHub;
using (var security = new SecurityProviderX509Certificate(certificate))
{
using (var transport = new ProvisioningTransportHandlerMqtt())
{
var provisioningClient = ProvisioningDeviceClient.Create("global.azure-devices-provisioning.net",
idScope, security, transport);
var provisioningResult = await provisioningClient.RegisterAsync();
Console.WriteLine(
$"Provisioning done - Assigned Hub: {provisioningResult.AssignedHub} - DeviceID {provisioningResult.DeviceId}");
auth = new DeviceAuthenticationWithX509Certificate(provisioningResult.DeviceId,
security.GetAuthenticationCertificate());
iotHub = provisioningResult.AssignedHub;
}
}
using (var deviceClient = DeviceClient.Create(iotHub, auth, TransportType.Mqtt))
{
await deviceClient.OpenAsync();
await deviceClient.SendEventAsync(
new Message(Encoding.UTF8.GetBytes("Auto provisioned device was here")));
await deviceClient.CloseAsync();
Console.WriteLine("Sent message");
}
}
static async Task Main()
{
var configuration = ReadConfiguration();
using X509Certificate2 certificate = LoadCertificate(configuration.DeviceName);
using var security = new SecurityProviderX509Certificate(certificate);
var registrationResult = await RegisterDeviceAsync(configuration, security);
var auth = new DeviceAuthenticationWithX509Certificate(registrationResult.DeviceId, security.GetAuthenticationCertificate());
using DeviceClient iotClient = DeviceClient.Create(registrationResult.AssignedHub, auth, TransportType.Amqp);
await iotClient.OpenAsync();
await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage")));
await iotClient.CloseAsync();
}
static async Task <DeviceClient> CreateForDPS(AuthType authType)
{
var dpsScope = Environment.GetEnvironmentVariable("DPSScope");
var security = new SecurityProviderX509Certificate(LoadCertificate());
var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly);
var provClient = ProvisioningDeviceClient.Create(dpsEndpoint, dpsScope, security, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception("Device could not be provisioned.");
}
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, security.GetAuthenticationCertificate());
return(DeviceClient.Create(result.AssignedHub, auth, transportType));
}
public async Task RunSampleAsync()
{
Console.WriteLine($"Loading the certificate...");
using X509Certificate2 certificate = LoadProvisioningCertificate();
using var security = new SecurityProviderX509Certificate(certificate);
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 X509 authentication for IoT Hub...");
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(
result.DeviceId,
certificate);
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 static int Main(string[] args)
{
X509Certificate2 certificate = LoadProvisioningCertificate();
using (var security = new SecurityProviderX509Certificate(certificate))
{
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);
}
public bool AddDeviceWithDeviceProvisioningCertificateAsync(string deviceId)
{
try
{
if (string.IsNullOrWhiteSpace(_dpsIdScope))
{
Console.WriteLine("ProvisioningDeviceClientX509 <IDScope>");
return(false);
}
var certificate = LoadPrivateKey(@"C:/Users/abgaurav/IOT/solutions/device-provisioning/key.pfx");
using (var security = new SecurityProviderX509Certificate(certificate))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(GlobalDeviceEndpoint, _dpsIdScope, security, transport);
//var result = await provClient.RegisterAsync();
//Console.WriteLine($"Provisioning result: {result.Status}");
//if (result.Status != ProvisioningRegistrationStatusType.Assigned)
//{
// throw new InvalidOperationException("Something went wrong while trying to provision.");
//}
//this.assignedHub = result.AssignedHub;
//this.auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, security.GetAuthenticationCertificate());
var sample = new ProvisioningDeviceClientSample(provClient, security);
sample.RunSampleAsync().GetAwaiter().GetResult();
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
// This version of ProvisionDevice is very similar to that you used in
// an earlier lab. The primary change is that the security parameter is
// now of type SecurityProviderX509Certificate. This means that the auth
// variable used to create a DeviceClient must now be of type
// DeviceAuthenticationWithX509Certificate and uses the
// security.GetAuthenticationCertificate() value. The actual device
// registration is the same as before.
private static async Task <DeviceClient> ProvisionDevice(
ProvisioningDeviceClient provisioningDeviceClient,
SecurityProviderX509Certificate security)
{
var result = await provisioningDeviceClient
.RegisterAsync()
.ConfigureAwait(false);
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
var auth = new DeviceAuthenticationWithX509Certificate(
result.DeviceId,
security.GetAuthenticationCertificate());
return(DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp));
}
public static async Task Main(string[] args)
{
var configuration = ReadConfiguration();
Console.WriteLine("Bootstrapping device...");
using X509Certificate2 certificate = LoadCertificate(configuration.DeviceName);
using var security = new SecurityProviderX509Certificate(certificate);
var registrationResult = await RegisterDeviceAsync(configuration, security);
var auth = new DeviceAuthenticationWithX509Certificate(registrationResult.DeviceId, security.GetAuthenticationCertificate());
using DeviceClient deviceClient = DeviceClient.Create(registrationResult.AssignedHub, auth, TransportType.Mqtt);
await deviceClient.SetMethodHandlerAsync(nameof(DestinationCall), DestinationCall, null);
await SendDeviceStateMessages(configuration.DeviceName, deviceClient);
//ReceiveC2dAsync(deviceClient);
Console.ReadKey();
}
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("ProvisioningDeviceClientX509 <IDScope>");
return(1);
}
#if false
X509Certificate2 certificate = LoadProvisioningCertificate();
using (var security = new SecurityProviderX509Certificate(certificate))
#else
var myCertificate = new X509Certificate2(s_certificateFileName, "1234");
var myChain = new X509Certificate2Collection();
// Comment out the below line if you do not have a .p7b file (e.g. if you generated certificates using the tool below)
//myChain.Import("myChain.p7b");
using (var security = new SecurityProviderX509Certificate(myCertificate, myChain))
#endif
// 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();
}
return(0);
}
public async Task Provision()
{
var certificate = LoadPrivateKey("key.pfx");
using (var securityProvider = new SecurityProviderX509Certificate(certificate))
using (var transport = new ProvisioningTransportHandlerAmqp(TransportFallbackType.TcpOnly))
{
var client = ProvisioningDeviceClient.Create("global.azure-devices-provisioning.net", this.scopeId, securityProvider, transport);
var result = await client.RegisterAsync();
Console.WriteLine($"Provisioning result: {result.Status}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new InvalidOperationException("Something went wrong while trying to provision.");
}
this.assignedHub = result.AssignedHub;
this.auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, securityProvider.GetAuthenticationCertificate());
}
}
private DeviceClient CreateModuleClientAsync(TransportType transportType)
{
var cert = DeviceAuthWithX509Certificate(certificate, password);
using (var security = new SecurityProviderX509Certificate(cert))
{
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(security.GetRegistrationID(),
(security as SecurityProviderX509).GetAuthenticationCertificate());
DeviceClient client = null;
try
{
ITransportSettings[] settings = new ITransportSettings[] { new MqttTransportSettings(transportType) };
DeviceClient deviceClient = DeviceClient.Create(hostName, auth, settings);
client = deviceClient;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(client);
}
}
