private static async Task ProvisionDeviceAsync(CancellationToken token)
{
string baseUrl = ConfigurationHelper.GetConfigValue <string>("WebApiEndpoint");
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(baseUrl);
string urlPath = String.Format("api/devices/{0}/provision", DEVICE_ID);
var result = await client.PostAsync(urlPath, null, token);
Console.WriteLine("{0} ({1})", (int)result.StatusCode, result.ReasonPhrase);
if (result.IsSuccessStatusCode)
{
var endpoint = await result.Content.ReadAsAsync <DeviceEndpoint>(token);
Console.WriteLine("Endpoint: {0}", endpoint.Uri);
Console.WriteLine("AccessToken: {0}", endpoint.AccessToken);
ConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri(endpoint.Uri),
endpoint.EventHubName,
DEVICE_ID,
endpoint.AccessToken
);
}
else if (result.StatusCode == HttpStatusCode.NotFound)
{
Console.WriteLine("You must register the device first.");
}
}
public void Scenario4_EventHubSendToPublisherWithToken(string sbnamespace, string eventHubEntity, string publisher, string sharedAccessKeyName, string sharedAccessKey)
{
string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature(
new Uri(sbnamespace),
eventHubEntity,
publisher,
sharedAccessKeyName,
sharedAccessKey,
new TimeSpan(0, 20, 0));
string connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri(sbnamespace),
eventHubEntity,
publisher,
token);
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString);
EventHubClient client = factory.CreateEventHubClient(eventHubEntity);
EventHubSender sender = client.CreateSender(publisher);
EventData data = new EventData(Encoding.UTF8.GetBytes("Body"));
data.Properties["time"] = DateTime.UtcNow;
sender.Send(data);
sender.Close();
client.Close();
factory.Close();
}
static void SendMessagesWithSas(string endpoint, string eventHubName, string publisherName, string sas)
{
var sasConnectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(new Uri(endpoint), eventHubName, publisherName, sas);
var sender = EventHubSender.CreateFromConnectionString(sasConnectionString);
var message = Guid.NewGuid().ToString();
Console.WriteLine("{0} > Sending message with SAS connection string : {1} from publisher {2}", DateTime.Now, message, publisherName);
var eventData = new EventData(Encoding.UTF8.GetBytes(message));
// Below partition key setting is not neccessary as it will be auto assigned with publishername in such scenario
//eventData.PartitionKey = publisherName;
try
{
sender.Send(eventData);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("{0} > Sent message {1} succesfully!", DateTime.Now, message);
Console.ResetColor();
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{0} > Exception: {1}", DateTime.Now, exception.Message);
Console.ResetColor();
}
}
public void Send(string a)
{
var sas = GetSas();
//Console.WriteLine("Creating EHSender");
var xon = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(new Uri(_sbNamespace), _hubName, _publisherName, sas);
var c = EventHubSender.CreateFromConnectionString(xon);
c.SendAsync(new EventData(System.Text.Encoding.UTF8.GetBytes($"{_publisherName} says {a}")));
//Console.WriteLine("Sent.");
}
private static EventHubSender CreateSender()
{
var publisher = "handsonazurepublisher";
var token = SharedAccessSignatureTokenProvider.GetSharedAccessSignature(KeyName, SASKey,
$"sb://{Namespace}.servicebus.windows.net/{HubName}/publishers/{publisher}", TimeSpan.FromHours(24));
var connectionString =
ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri($"sb://{Namespace}.servicebus.windows.net"), HubName, publisher, token);
var eventHubSender = EventHubSender.CreateFromConnectionString(connectionString);
return(eventHubSender);
}
public EventHubReporter(ServiceDescriptor service, EventHubConnectionInfo eventHubConnection)
{
Require.NotNull(service, nameof(service));
Require.NotNull(eventHubConnection, nameof(eventHubConnection));
var connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
endpoint: eventHubConnection.Namespace,
entityPath: eventHubConnection.Hub,
publisher: MetricsPublihser.GetPublisherId(service),
sharedAccessSignature: eventHubConnection.SharedAccessSignature);
m_service = service;
m_eventHubConnection = eventHubConnection;
m_sender = EventHubSender.CreateFromConnectionString(connectionString);
}
public EventSender(
Device device,
SimulatorConfiguration config,
Func <object, byte[]> serializer)
{
this._serializer = serializer;
var connectionString = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
device.Endpoint,
device.EventHubName,
device.Id,
device.Token
);
_eventHubSender = EventHubSender.CreateFromConnectionString(connectionString);
}
private static string GenerateTokenAndCheck(Uri namaSpaceUri, string hubName, string publisher, string policy, string key)
{
string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature(
namaSpaceUri,
hubName,
publisher,
policy,
key,
new TimeSpan(365, 0, 0));
var connStr = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
namaSpaceUri,
hubName,
publisher,
token);
CheckToken(connStr);
return(token);
}
static void Main(string[] args)
{
if (1 > args.Length)
{
Usage();
return;
}
//
// Perform the operation indicated by the first command line
// argument
//
if (0 == String.Compare(args[0], OPERATION_REGISTER, true))
{
//
// Create an attested key
//
CngProvider cng = new CngProvider(SNKSP);
CngKeyCreationParameters createParams = new CngKeyCreationParameters();
createParams.Provider = cng;
createParams.KeyCreationOptions = CngKeyCreationOptions.None;
CngKey snKey = CngKey.Create(
CngAlgorithm2.Rsa, ATTESTED_KEY_NAME, createParams);
//
// Create a signed request message
//
StringBuilder pubKeyHashString = null;
byte[] registrationRequest = CryptoHelper.CreateMessageWithPrependedSignatureAndPublicKey(
snKey, ref pubKeyHashString);
//
// Save the message
//
File.WriteAllBytes(REQUEST_FILE_NAME, registrationRequest);
Console.WriteLine(
"Success: created registration request for publisher ID {0}",
pubKeyHashString);
}
else if (0 == String.Compare(args[0], OPERATION_PROVIDETOKEN, true))
{
//
// Receive the publisher token request
//
byte[] publisherTokenRequest = File.ReadAllBytes(REQUEST_FILE_NAME);
//
// Check the signature
//
StringBuilder publisherPubKeyHashString = null;
if (false == CryptoHelper.VerifyMessageWithPrependedSignatureAndPublicKey(
publisherTokenRequest, ref publisherPubKeyHashString))
{
return;
}
//
// Read the location of the StrongNet Attestation Server
//
RegistryKey snReg =
Registry.LocalMachine.OpenSubKey(SNKSP_REG_KEY, false);
string snAsUri = (string)snReg.GetValue(SNSERVICEURI_REG_VALUE);
//
// Confirm with the StrongNet Attestation Server that this is
// an attested key
//
var client = new RestClient(String.Format(
"{0}/{1}", snAsUri, SNAPI_ROOT));
var request = new RestRequest("MbkAttestation", Method.GET);
request.AddQueryParameter(
"publicKeyHash", publisherPubKeyHashString.ToString());
var response = client.Execute(request);
if (System.Net.HttpStatusCode.OK != response.StatusCode ||
ResponseStatus.Completed != response.ResponseStatus)
{
Console.WriteLine("Error: invalid publisher token request public key");
return;
}
//
// Using Publisher Policy, acquire a shared access token,
// simulating registration. This would happen on the server in
// order to limit exposure of the Azure access key.
//
// http://blogs.msdn.com/b/servicebus/archive/2015/02/02/event-hub-publisher-policy-in-action.aspx
//
// Timespan can be long if the registration server checks every
// publisher with the attestation server, the event processor checks a
// signature on every message, publisher IDs can be revoked, and
// you trust the storage of your policy key.
//
string token = SharedAccessSignatureTokenProvider.GetPublisherSharedAccessSignature(
new Uri(SERVICE_BUS_URI),
EVENT_HUB_NAME,
publisherPubKeyHashString.ToString(),
SENDER_POLICY_KEY_NAME,
args[1],
new TimeSpan(0, 30, 0));
//
// Send the token back to the requestor
//
File.WriteAllText(TOKEN_FILE_NAME, token);
Console.WriteLine(
"Success: issued SAS policy '{0}' token to publisher ID {1}",
SENDER_POLICY_KEY_NAME,
publisherPubKeyHashString);
}
else if (0 == String.Compare(args[0], OPERATION_SENDDATA, true))
{
//
// Read back a previously acquired Azure Service Bus publisher token
//
string token = File.ReadAllText(TOKEN_FILE_NAME);
//
// Open the attested key
//
CngProvider cng = new CngProvider(SNKSP);
CngKey snKey = CngKey.Open(ATTESTED_KEY_NAME, cng);
//
// Create a new signed message to simulate what will get posted
// by each sender to the event hub.
//
StringBuilder pubKeyHashString = null;
byte[] signedMessage = CryptoHelper.CreateMessageWithPrependedSignatureAndPublicKey(
snKey, ref pubKeyHashString);
//
// Create a connection string for this policy and hub. Using
// the hash of the public key as the publisher identity
// allows correlation between security policy compliance and
// sender data streams (but only if the processor verifies a
// message signature and that the public key is known to the
// attestation server).
//
string connStr = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessSignature(
new Uri(SERVICE_BUS_URI),
EVENT_HUB_NAME,
pubKeyHashString.ToString(),
token);
//
// Create a sender for this connection
//
EventHubSender sender = EventHubSender.CreateFromConnectionString(connStr);
//
// Send the signed message
//
sender.Send(new EventData(signedMessage));
Console.WriteLine("Success: message sent");
}
else if (0 == String.Compare(args[0], OPERATION_LISTENDATA, true))
{
//
// Create a receiver for the indicated policy
//
string evtConnStr = ServiceBusConnectionStringBuilder.CreateUsingSharedAccessKey(
new Uri(SERVICE_BUS_URI), LISTEN_POLICY_KEY_NAME, args[1]);
string storageConnStr = string.Format(
"DefaultEndpointsProtocol=https;AccountName={0};AccountKey={1}",
args[2],
args[3]);
//
// Use a variation of multi-threaded listener sample code from
// Microsoft. This saves us from having to know which partition
// the test message got queued to.
//
// http://azure.microsoft.com/en-us/documentation/articles/service-bus-event-hubs-csharp-ephcs-getstarted/
//
var processorHost = new EventProcessorHost(
Guid.NewGuid().ToString(),
EVENT_HUB_NAME,
EventHubConsumerGroup.DefaultGroupName,
evtConnStr,
storageConnStr);
processorHost.RegisterEventProcessorAsync <SignatureCheckingEventProcessor>().Wait();
Console.WriteLine("Receiving. Press enter key to stop worker.");
Console.ReadLine();
}
else if (0 == String.Compare(args[0], OPERATION_REVOKEPUBLISHER, true))
{
//
// Create a namespace manager from a connection string acquired
// from the Azure management portal
//
var nsm = Microsoft.ServiceBus.NamespaceManager.CreateFromConnectionString(
args[1]);
//
// Revoke this publisher
//
nsm.RevokePublisher(EVENT_HUB_NAME, args[2]);
//
// List revoked publishers
//
var revokedPublishers = nsm.GetRevokedPublishers(EVENT_HUB_NAME);
//
// Restore this publisher
//
nsm.RestorePublisher(EVENT_HUB_NAME, args[2]);
}
else
{
Usage();
}
}