Authentifizieren Sie den Zugriff auf Event Hubs-Ressourcen mithilfe von Shared Access Signatures (SAS)

Durch die Verwendung einer Shared-Access-Signatur (SAS) können Sie steuern, welche Art von Zugriff Sie den Kunden gewähren. Sie können die folgenden Steuerungen in einem SAS einstellen:

• Das Intervall, in dem die SAS gültig ist, einschließlich der Startzeit und der Ablaufzeit.
• Berechtigungen, die von der SAS gewährt werden. Zum Beispiel könnte ein SAS für einen Event Hubs-Namensraum die Berechtigung gewähren, Ereignisse zu empfangen, aber nicht die Berechtigung, Ereignisse zu senden.

Die SAS-Authentifizierung bietet folgende Vorteile:

• Nur Clients, die gültige Anmeldeinformationen bereitstellen, können Daten an einen Event Hub senden.
• Ein Client kann nicht die Identität eines anderen Clients annehmen.
• Du kannst einen unzuverlässigen Client daran hindern, Daten an einen Event-Hub zu senden.

Dieser Artikel behandelt die Authentifizierung des Zugangs zu Event Hubs-Ressourcen mittels SAS. Um mehr über die Autorisierung des Zugriffs auf Event Hubs-Ressourcen durch SAS zu erfahren, siehe Authorize access to Event Hubs resources using shared access signatures.

Konfigurieren Sie die SAS-Authentifizierung

Sie können eine SAS-Regel für einen Event Hubs-Namespace oder eine Entität (Event Hub oder Kafka-Thema) konfigurieren. Die Konfiguration einer SAS-Regel in einer Consumer-Gruppe wird nicht unterstützt, aber Sie können Regeln verwenden, die auf einem Namespace oder einer Entität konfiguriert sind, um den Zugriff auf eine Consumer-Gruppe zu sichern. Die folgende Abbildung zeigt, wie die Autorisierungsregeln auf Beispielentitäten angewendet werden.

In diesem Beispiel enthält der Event Hubs-Beispielnamespace (ExampleNamespace) zwei Entitäten: „eh1“ und „topic1“ von Kafka. Die Autorisierungsregeln werden sowohl auf Entitätsebene als auch auf Namespaceebene definiert.

Die Autorisierungsregeln „manageRuleNS“, „sendRuleNS“ und „listenRuleNS“ gelten sowohl für „eh1“ als auch für „topic1“. Die Autorisierungsregeln „listenRule-eh“ und „sendRule-eh“ gelten nur für „eh1“, und die Autorisierungsregel „sendRuleT“ gilt nur für das „topic1“.

Wenn Sie die Autorisierungsregel „sendRuleNS“ verwenden, können Clientanwendungen sowohl an „eh1“ als auch an „topic1“ Daten senden. Bei Verwendung der Autorisierungsregel „sendRuleT“ wird nur der differenzierte Zugriff auf „topic1“ erzwungen. Daher können Clientanwendungen, die diese Regel für den Zugriff verwenden, keine Daten an „eh1“ senden, sondern nur an „topic1“.

Generieren eines SAS-Tokens

Jeder Client, der Zugriff auf den Namen einer Autorisierungsregel hat, und eines seiner Signaturschlüssel kann ein SAS-Token generieren. Generieren Sie das Token, indem Sie eine Zeichenkette im folgenden Format erstellen:

• se: Tokenablaufwert. Eine ganze Zahl, die die Anzahl von Sekunden seit der Epoche 00:00:00 Uhr UTC am 1. Januar 1970 (UNIX-Epoche) beim Ablauf des Tokens darstellt.
• skn: Name der Autorisierungsregel, d. h. der Name des SAS-Schlüssels.
• sr: URI der Ressource, auf die zugegriffen wird.
• sig: Signatur.

Die Signaturzeichenfolge ist der HMAC-SHA256-Hash, der über den Ressourcen-URI berechnet wird (der im vorherigen Abschnitt beschriebene Bereich), und eine Zeichenfolgendarstellung des Tokenablaufwerts, getrennt durch einen Zeilenvorschub (Line Feed, LF). Signieren Sie den Hash mit einem der Signaturschlüssel der Autorisierungsregel. Die Hashberechnung liefert einen Hashwert von 256 Bit/32 Bytes.

HMAC-SHA256(signingKey, 'https://<yournamespace>.servicebus.windows.net/' + '\n' + 1438205742)

Das Token enthält die nicht gehashten Werte, sodass der Empfänger den Hash mit denselben Parametern neu berechnen und überprüfen kann, ob der Herausgeber einen gültigen Signierschlüssel besitzt.

Der Ressourcen-URI ist der vollständige URI der Service Bus-Ressource, auf die der Zugriff beansprucht wird. Zum Beispiel http://<namespace>.servicebus.windows.net/<entityPath> oder sb://<namespace>.servicebus.windows.net/<entityPath>, wie http://contoso.servicebus.windows.net/eh1.

Kodieren Sie die URI prozentual.

Konfigurieren Sie die zum Signieren verwendete SAS-Regel für die durch diesen URI oder einen seiner hierarchisch übergeordneten Elemente angegebene Entität. Beispiel: http://contoso.servicebus.windows.net/eh1 oder http://contoso.servicebus.windows.net im vorherigen Beispiel.

Ein SAS-Token ist für alle Ressourcen mit dem Präfix <resourceURI> in der Signaturzeichenfolge gültig.

Generiere eine Signatur (Token) aus einer Richtlinie

Der folgende Abschnitt zeigt, wie man ein SAS-Token unter Verwendung von Shared-Access-Signaturrichtlinien generiert.

Node.js

function createSharedAccessToken(uri, saName, saKey) { 
  if (!uri || !saName || !saKey) { 
          throw "Missing required parameter"; 
      } 
  var encoded = encodeURIComponent(uri); 
  var now = new Date(); 
  var week = 60*60*24*7;
  var ttl = Math.round(now.getTime() / 1000) + week;
  var signature = encoded + '\n' + ttl; 
  var hash = crypto.createHmac('sha256', saKey).update(signature, 'utf8').digest('base64'); 
  return 'SharedAccessSignature sr=' + encoded + '&sig=' +  
      encodeURIComponent(hash) + '&se=' + ttl + '&skn=' + saName; 
}

Um einen Richtliniennamen und einen Schlüsselwert zum Herstellen einer Verbindung mit einem Event Hub zu verwenden, nutzen Sie den Konstruktor EventHubProducerClient, der den Parameter AzureNamedKeyCredential verwendet.

const producer = new EventHubProducerClient("NAMESPACE NAME.servicebus.windows.net", eventHubName, new AzureNamedKeyCredential("POLICYNAME", "KEYVALUE"));

Fügen Sie einen Verweis auf AzureNamedKeyCredential.

const { AzureNamedKeyCredential } = require("@azure/core-auth");

Um ein SAS-Token zu verwenden, das du mit dem Code erstellst, verwende den EventHubProducerClient Konstruktor, der den Parameter AzureSASCredential nimmt.

var token = createSharedAccessToken("https://NAMESPACENAME.servicebus.windows.net", "POLICYNAME", "KEYVALUE");
const producer = new EventHubProducerClient("NAMESPACENAME.servicebus.windows.net", eventHubName, new AzureSASCredential(token));

Fügen Sie einen Verweis auf AzureSASCredential.

const { AzureSASCredential } = require("@azure/core-auth");

Java

private static String GetSASToken(String resourceUri, String keyName, String key)
  {
      long epoch = System.currentTimeMillis()/1000L;
      int week = 60*60*24*7;
      String expiry = Long.toString(epoch + week);

      String sasToken = null;
      try {
          String stringToSign = URLEncoder.encode(resourceUri, "UTF-8") + "\n" + expiry;
          String signature = getHMAC256(key, stringToSign);
          sasToken = "SharedAccessSignature sr=" + URLEncoder.encode(resourceUri, "UTF-8") +"&sig=" +
                  URLEncoder.encode(signature, "UTF-8") + "&se=" + expiry + "&skn=" + keyName;
      } catch (UnsupportedEncodingException e) {

          e.printStackTrace();
      }

      return sasToken;
  }


public static String getHMAC256(String key, String input) {
    Mac sha256_HMAC = null;
    String hash = null;
    try {
        sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(key.getBytes(), "HmacSHA256");
        sha256_HMAC.init(secret_key);
        Encoder encoder = Base64.getEncoder();

        hash = new String(encoder.encode(sha256_HMAC.doFinal(input.getBytes("UTF-8"))));

    } catch (InvalidKeyException e) {
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
   } catch (IllegalStateException e) {
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }

    return hash;
}

PHP

function generateSasToken($uri, $sasKeyName, $sasKeyValue) 
{ 
    $targetUri = strtolower(rawurlencode(strtolower($uri))); 
    $expires = time(); 	
    $expiresInMins = 60; 
    $week = 60*60*24*7;
    $expires = $expires + $week; 
    $toSign = $targetUri . "\n" . $expires; 
    $signature = rawurlencode(base64_encode(hash_hmac('sha256', 			
     $toSign, $sasKeyValue, TRUE))); 
    
    $token = "SharedAccessSignature sr=" . $targetUri . "&sig=" . $signature . "&se=" . $expires . 		"&skn=" . $sasKeyName; 
    return $token; 
}

C#

private static string createToken(string resourceUri, string keyName, string key)
{
    TimeSpan sinceEpoch = DateTime.UtcNow - new DateTime(1970, 1, 1);
    var week = 60 * 60 * 24 * 7;
    var expiry = Convert.ToString((int)sinceEpoch.TotalSeconds + week);
    string stringToSign = HttpUtility.UrlEncode(resourceUri) + "\n" + expiry;
    using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(key)))
    {
        var signature = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(stringToSign)));
        var sasToken = String.Format(CultureInfo.InvariantCulture, "SharedAccessSignature sr={0}&sig={1}&se={2}&skn={3}", HttpUtility.UrlEncode(resourceUri), HttpUtility.UrlEncode(signature), expiry, keyName);
        return sasToken;
    }
}

PowerShell

[Reflection.Assembly]::LoadWithPartialName("System.Web")| out-null
$URI="myNamespace.servicebus.windows.net/myEventHub/"
$Access_Policy_Name="RootManageSharedAccessKey"
$Access_Policy_Key="myPrimaryKey"
#Token expires now+300
$Expires=([DateTimeOffset]::Now.ToUnixTimeSeconds())+300
$SignatureString=[System.Web.HttpUtility]::UrlEncode($URI)+ "`n" + [string]$Expires
$HMAC = New-Object System.Security.Cryptography.HMACSHA256
$HMAC.key = [Text.Encoding]::ASCII.GetBytes($Access_Policy_Key)
$Signature = $HMAC.ComputeHash([Text.Encoding]::ASCII.GetBytes($SignatureString))
$Signature = [Convert]::ToBase64String($Signature)
$SASToken = "SharedAccessSignature sr=" + [System.Web.HttpUtility]::UrlEncode($URI) + "&sig=" + [System.Web.HttpUtility]::UrlEncode($Signature) + "&se=" + $Expires + "&skn=" + $Access_Policy_Name
$SASToken

Bash

get_sas_token() {
    local EVENTHUB_URI='EVENTHUBURI'
    local SHARED_ACCESS_KEY_NAME='SHAREDACCESSKEYNAME'
    local SHARED_ACCESS_KEY='SHAREDACCESSKEYVALUE'
    local EXPIRY=${EXPIRY:=$((60 * 60 * 24))} # Default token expiry is 1 day

    local ENCODED_URI=$(echo -n $EVENTHUB_URI | jq -s -R -r @uri)
    local TTL=$(($(date +%s) + $EXPIRY))
    local UTF8_SIGNATURE=$(printf "%s\n%s" $ENCODED_URI $TTL | iconv -t utf8)

    local HASH=$(echo -n "$UTF8_SIGNATURE" | openssl sha256 -hmac $SHARED_ACCESS_KEY -binary | base64)
    local ENCODED_HASH=$(echo -n $HASH | jq -s -R -r @uri)

    echo -n "SharedAccessSignature sr=$ENCODED_URI&sig=$ENCODED_HASH&se=$TTL&skn=$SHARED_ACCESS_KEY_NAME"
}

Event Hubs-Publisher mit SAS authentifizieren

Ein Ereignisherausgeber definiert einen virtuellen Endpunkt für einen Event Hub. Der Herausgeber kann nur zum Senden von Nachrichten an einen Event Hub verwendet werden, nicht zum Empfangen von Nachrichten.

In der Regel setzt ein Event Hub einen Herausgeber pro Client ein. Alle Nachrichten, die an einen der Herausgeber eines Event Hubs gesendet werden, werden in die Warteschlange innerhalb dieses Event Hubs eingereiht. Herausgeber ermöglichen eine präzise Zugriffssteuerung.

Jedem Event Hubs-Client wird ein eindeutiges Token zugewiesen, das auf den Client hochgeladen wird. Token werden so erzeugt, dass jedes eindeutige Token Zugriff auf einen anderen eindeutigen Herausgeber gewährt. Ein Client, der über ein Token verfügt, kann nur an einen Herausgeber Daten senden und an keinen anderen. Wenn mehrere Clients dasselbe Token gemeinsam nutzen, verwendet jeder von ihnen denselben Herausgeber.

Alle Token werden mit SAS-Schlüsseln zugewiesen. Alle Token werden in der Regel mit demselben Schlüssel signiert. Clients kennen den Schlüssel nicht. Clients können daher keine Token generieren. Clients verwenden die gleichen Token, bis diese ablaufen.

Um zum Beispiel Autorisierungsregeln zu definieren, die nur auf das Senden oder Veröffentlichen an Event Hubs beschränkt sind, muss man eine Sendeautorisierungsregel definieren. Man kann die Regel auf Namespace-Ebene erstellen oder einer bestimmten Entität, wie z. B. einer Event Hubs-Instanz oder einem Thema, einen detaillierteren Umfang geben. Ein Client oder eine Anwendung, die diesen granularen Zugriff hat, wird als Event Hubs-Publisher bezeichnet. Um diese Authentifizierung einzurichten, folgen Sie diesen Schritten:

1. Erstelle einen SAS-Schlüssel auf der Entität, an die du veröffentlichen möchtest, und weist ihr den Send-Scope zu. Weitere Informationen finden Sie unter Shared access authorization policies (SAS-Autorisierungsrichtlinien).

2. Generiere ein SAS-Token mit einer Ablaufzeit für einen bestimmten Publisher, indem du den Schlüssel verwendest, den du in Schritt 1 erstellt hast. Für den Beispielcode siehe Generiere eine Signatur (Token) aus einer Richtlinie.

3. Stellen Sie das Token dem Publisher-Client zur Verfügung, der nur an die Entität und den Publisher senden kann, auf die das Token Zugriff gewährt.

   Wenn das Token abläuft, verliert der Client seinen Zugriff, an die Entität zu senden oder zu veröffentlichen.

Authentifizieren Sie Event Hubs-Kunden mit SAS

Um Back-End-Anwendungen zu authentifizieren, die von Event Hubs-Produzenten generierte Daten nutzen, erfordert die Event Hubs-Tokenauthentifizierung, dass ihre Clients entweder über die Verwaltungsrechte oder die Listenberechtigungen verfügen, die ihrem Event Hubs-Namespace oder Event Hub-Instanz oder Thema zugewiesen sind. Daten werden von Event Hubs mithilfe von Consumergruppen genutzt. Mit einer SAS-Richtlinie können Sie zwar einen präzisen Bereich festlegen, dieser Bereich wird aber nur auf der Entitätsebene definiert und nicht auf der Consumerebene. Die auf Namespace-, Event Hub- oder Themenebene definierten Berechtigungen werden folglich auf die Consumergruppen dieser Entität angewendet.

Lokale oder SAS-Schlüssel-Authentifizierung deaktivieren

Für bestimmte Sicherheitsanforderungen der Organisation müssen Sie die Authentifizierung mit lokalem Schlüssel bzw. SAS-Schlüssel vollständig deaktivieren und sich auf die Microsoft Entra ID-basierte Authentifizierung verlassen. Dies ist die empfohlene Methode zum Herstellen einer Verbindung mit Azure Event Hubs. Sie können die Authentifizierung mit lokalem/SAS-Schlüssel auf der Event Hubs-Namespaceebene deaktivieren, indem Sie das Azure-Portal oder eine Azure Resource Manager-Vorlage verwenden.

Deaktivieren Sie die lokale oder SAS-Schlüssel-Authentifizierung über das Portal

Sie können die Authentifizierung mit lokalem/SAS-Schlüssel für einen bestimmten Event Hubs-Namespace mithilfe von Azure-Portal deaktivieren.

1. Navigieren Sie im Azure-Portal zu Ihrem Event Hubs-Namespace.

2. Wählen Sie auf der Seite Übersicht für Lokale Authentifizierung die Option Aktiviert aus, wie in der folgenden Abbildung zu sehen:

   

3. Wählen Sie im Popupfenster Lokale Authentifizierung die Option Deaktiviert und dann OK aus.

   

Deaktivieren Sie die lokale oder SAS-Schlüssel-Authentifizierung mithilfe einer Vorlage

Sie können die lokale Authentifizierung für einen bestimmten Event Hubs-Namespace deaktivieren, indem Sie die Eigenschaft disableLocalAuth wie in der folgenden Azure Resource Manager-Vorlage (ARM-Vorlage) gezeigt auf true festlegen.

{
  "apiVersion": "2024-01-01",
  "name": "[parameters('eventHubNamespaceName')]",
  "type": "Microsoft.EventHub/Namespaces",
  "location": "[resourceGroup().location]",
  "sku": {
    "name": "Standard",
    "tier": "Standard"
  },
  "properties": {
    "isAutoInflateEnabled": true,
    "maximumThroughputUnits": 7,
    "disableLocalAuth": true
  },
  "resources": [
    {
      "apiVersion": "2024-01-01",
      "name": "[parameters('eventHubName')]",
      "type": "EventHubs",
      "dependsOn": [
        "[concat('Microsoft.EventHub/namespaces/', parameters('eventHubNamespaceName'))]"
      ],
      "properties": {
        "messageRetentionInDays": "[parameters('messageRetentionInDays')]",
        "partitionCount": "[parameters('partitionCount')]"
      }
    }
  ]
}

Samples

• Im .NET-Beispiel #6 an diesem GitHub-Speicherort erfahren Sie, wie Sie Ereignisse mithilfe von Anmeldeinformationen für den gemeinsamen Zugriff oder der Standardidentität von Azure-Anmeldeinformationen in einem Event Hub veröffentlichen.
• Im .NET-Beispiel #5 an diesem GitHub-Speicherort erfahren Sie, wie Sie Ereignisse mithilfe von Anmeldeinformationen für den gemeinsamen Zugriff oder der Standardidentität von Azure-Anmeldeinformationen nutzen oder verarbeiten.

Verwandte Inhalte

Jetzt, da Sie die SAS-Authentifizierung verstanden haben, lesen Sie diese verwandten Artikel:

• Autorisieren Sie Zugriff auf Event Hubs-Ressourcen mithilfe von Shared-Access-Signaturen – Lernen Sie Autorisierungskonzepte.
• Zugriff auf Event Hubs mit Microsoft Entra ID autorisieren – Implementierung von Unternehmenssicherheit.