Event Hubs-erőforrásokhoz való hozzáférés hitelesítése közös hozzáférésű jogosultságkódokkal (SAS)

A közös hozzáférésű jogosultságkód (SAS) részletes vezérlést biztosít a közös hozzáférésű jogosultságkóddal rendelkező ügyfeleknek nyújtott hozzáférés típusa felett. Az SAS-ben az alábbi vezérlők állíthatók be:

• Az az időtartam, amely alatt az SAS érvényes, beleértve a kezdési és a lejárati időt is.
• Az SAS által megadott engedélyek. Egy Event Hubs-névtér SAS-jének például lehet, hogy a figyelés engedélyt adja meg, a küldési engedélyt azonban nem.
• Csak az érvényes hitelesítő adatokat tartalmazó ügyfelek küldhetnek adatokat az eseményközpontba.
• Egy ügyfél nem tud megszemélyesíteni egy másik ügyfelet.
• A csaló ügyfelek nem küldhetnek adatokat egy eseményközpontba.

Ez a cikk az Event Hubs-erőforrások sas használatával történő hitelesítését ismerteti. Az Event Hubs-erőforrások SAS-sel való elérésének engedélyezésérőlebben a cikkben olvashat.

Megjegyzés

A Microsoft azt javasolja, hogy ha lehetséges, használja az Azure AD hitelesítő adatait biztonsági ajánlott eljárásként a közös hozzáférésű jogosultságkódok használata helyett, ami könnyebben sérülhet. Bár továbbra is használhat közös hozzáférésű jogosultságkódokat (SAS) az Event Hubs-erőforrások részletes hozzáférésének biztosításához, az Azure AD hasonló képességeket kínál anélkül, hogy kezelnie kellene az SAS-jogkivonatokat, vagy aggódnia kellene egy feltört SAS visszavonása miatt.

További információ az Azure AD Azure Event Hubs-integrációjáról: Event Hubs-hozzáférés engedélyezése az Azure AD használatával.

Konfigurálás SAS-hitelesítéshez

Konfigurálhatja az EventHubs megosztott hozzáférés-engedélyezési szabályát egy Event Hubs-névtéren vagy entitáson (eseményközpont-példányon vagy Kafka-témakör egy eseményközpontban). A megosztott hozzáférés engedélyezési szabályának konfigurálása egy fogyasztói csoporton jelenleg nem támogatott, de egy névtéren vagy entitáson konfigurált szabályokkal biztonságossá teheti a fogyasztói csoporthoz való hozzáférést.

Az alábbi kép bemutatja, hogyan vonatkoznak az engedélyezési szabályok a mintaentitásokra.

Ebben a példában a minta Event Hubs-névtér (ExampleNamespace) két entitással rendelkezik: eh1 és topic1. Az engedélyezési szabályok az entitás szintjén és a névtér szintjén is definiálva vannak.

A manageRuleNS, a sendRuleNS és a listenRuleNS engedélyezési szabályok az event hub eh1 példányára és a t1. témakörre egyaránt vonatkoznak. A listenRule-eh és a sendRule-eh engedélyezési szabályok csak az event hub eh1 példányára vonatkoznak, a sendRuleT engedélyezési szabály pedig csak az 1. témakörre vonatkozik.

A sendRuleNS engedélyezési szabály használatakor az ügyfélalkalmazások elküldhetők az eh1 és a topic1 témakörbe is. A sendRuleT engedélyezési szabály használatakor csak az 1. témakörhöz való részletes hozzáférést kényszeríti ki, így az ezt a szabályt hozzáférésre használó ügyfélalkalmazások mostantól nem küldhetnek az eh1-nek, csak a topic1-nek.

Közös hozzáférésű jogosultságkód jogkivonatának létrehozása

Bármely ügyfél, amely hozzáféréssel rendelkezik egy engedélyezési szabály nevéhez és annak egyik aláíró kulcsához, létrehozhat egy SAS-jogkivonatot. A jogkivonatot egy sztring a következő formátumban történő megadásával hozza létre:

• se – A jogkivonat lejárata azonnal. Az alapidőszak óta eltelt másodperceket tükröző egész szám 1970. január 1-jén (UNIX alapidőszak) (UTC) a jogkivonat lejárata óta
• skn – Az engedélyezési szabály neve, azaz az SAS-kulcs neve.
• sr – A hozzáférés alatt álló erőforrás URI-ja.
• sig – Aláírás.

Az aláírási sztring az erőforrás URI-ja alapján kiszámított SHA-256 kivonat (a hatókör az előző szakaszban leírtak szerint), valamint a jogkivonat lejáratának sztringje azonnal, CRLF-el elválasztva.

A kivonatszámítás az alábbi pszeudokódhoz hasonlít, és egy 256 bites/32 bájtos kivonatértéket ad vissza.

SHA-256('https://<yournamespace>.servicebus.windows.net/'+'\n'+ 1438205742)

A jogkivonat tartalmazza a nem kivonatolt értékeket, így a címzett újrafordíthatja a kivonatot ugyanazokkal a paraméterekkel, és ellenőrizheti, hogy a kiállító rendelkezik-e érvényes aláíró kulccsal.

Az erőforrás URI-ja annak a Service Bus erőforrásnak a teljes URI-ja, amelyhez hozzáférést igényel. Például. http://<namespace>.servicebus.windows.net/<entityPath>sb://<namespace>.servicebus.windows.net/<entityPath>http://contoso.servicebus.windows.net/eh1

Az URI-nak százalékban kódoltnak kell lennie.

Az aláíráshoz használt közös hozzáférés-engedélyezési szabályt az URI által megadott entitáson vagy annak egyik hierarchikus szülőjének kell konfigurálnia. Például, http://contoso.servicebus.windows.net/eh1 vagy http://contoso.servicebus.windows.net az előző példában.

Az SAS-jogkivonat az aláírási sztringben <resourceURI> használt összes erőforrásra érvényes.

Megjegyzés

Hozzáférési jogkivonatot hoz létre az Event Hubs számára megosztott hozzáférési szabályzat használatával. További információ: Megosztott hozzáférés engedélyezési szabályzata.

Aláírás(jogkivonat) létrehozása szabályzatból

A következő szakasz azt mutatja be, hogy közös hozzáférésű jogosultságkód-szabályzatokkal hoz létre SAS-jogkivonatot,

NodeJS

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 signatureUTF8 = utf8.encode(signature); 
    var hash = crypto.createHmac('sha256', saKey).update(signatureUTF8).digest('base64'); 
    return 'SharedAccessSignature sr=' + encoded + '&sig=' +  
        encodeURIComponent(hash) + '&se=' + ttl + '&skn=' + saName; 

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=$1
    local SHARED_ACCESS_KEY_NAME=$2
    local SHARED_ACCESS_KEY=$3
    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-közzétevők hitelesítése SAS-lel

Az esemény-közzétevő definiál egy virtuális végpontot egy eseményközponthoz. A közzétevő csak arra használható, hogy üzeneteket küldjön egy eseményközpontba, és ne fogadjon üzeneteket.

Az eseményközpontok általában ügyfelenként egy közzétevőt alkalmaznak. Az eseményközpont közzétevőinek küldött összes üzenet az adott eseményközponton belül lesz beágyazva. A közzétevők lehetővé teszik a részletes hozzáférés-vezérlést.

Minden Event Hubs-ügyfélhez egyedi jogkivonat van rendelve, amelyet a rendszer feltölt az ügyfélre. A jogkivonatok úgy jönnek létre, hogy mindegyik egyedi jogkivonat hozzáférést biztosít a különböző egyedi közzétevőkhöz. A jogkivonatot tartalmazó ügyfelek csak egy közzétevőnek küldhetnek, más közzétevőknek nem. Ha több ügyfél osztozik ugyanazon a jogkivonaton, mindegyik megosztja a közzétevőt.

Minden jogkivonat SAS-kulcsokkal van hozzárendelve. Általában minden jogkivonat ugyanazzal a kulccsal van aláírva. Az ügyfelek nem ismerik a kulcsot, ami megakadályozza, hogy az ügyfelek tokeneket gyártanak. Az ügyfelek ugyanazokat a jogkivonatokat alkalmazzák, amíg le nem járnak.

Ha például csak az Event Hubsban való küldésre/közzétételre vonatkozó engedélyezési szabályokat szeretne meghatározni, meg kell határoznia egy küldési engedélyezési szabályt. Ez elvégezhető névtérszinten, vagy részletesebb hatókört adhat egy adott entitásnak (event hubs-példány vagy témakör). Az ilyen részletes hozzáféréssel rendelkező ügyfél vagy alkalmazás neve Event Hubs-közzétevő. Ehhez kövesse az alábbi lépéseket:

1. Hozzon létre egy SAS-kulcsot a közzétenni kívánt entitáson a küldési hatókör hozzárendeléséhez. További információ: Megosztott hozzáférés engedélyezési szabályzatai.

2. Hozzon létre egy SAS-jogkivonatot egy adott közzétevő lejárati idejével az 1. lépésben létrehozott kulcs használatával. A mintakódért lásd: Aláírás(jogkivonat) létrehozása szabályzatból.

3. Adja meg a jogkivonatot a közzétevő ügyfélnek, amely csak arra az entitásra tud küldeni, amelyhez a jogkivonat hozzáférést biztosít.

   A jogkivonat lejárata után az ügyfél elveszíti a hozzáférését az entitáson való küldéshez/közzétételhez.

Megjegyzés

Bár nem ajánlott, az eszközök olyan jogkivonatokkal is elláthatók, amelyek hozzáférést biztosítanak egy eseményközponthoz vagy névtérhez. A jogkivonatot tartalmazó eszközök közvetlenül az adott eseményközpontba küldhetnek üzeneteket. Továbbá az eszköz nem tiltható le az adott eseményközpontba való küldés letiltásához.

Mindig ajánlott adott és részletes hatóköröket megadni.

Fontos

A jogkivonatok létrehozása után minden ügyfél saját egyedi jogkivonattal lesz kiépítve.

Amikor az ügyfél adatokat küld egy eseményközpontba, a kérést a jogkivonattal címkézi. Ha meg szeretné akadályozni, hogy egy támadó lehallgatja és ellopja a jogkivonatot, az ügyfél és az eseményközpont közötti kommunikációnak titkosított csatornán kell történnie.

Ha egy támadó ellop egy jogkivonatot, a támadó megszemélyesítheti azt az ügyfelet, akinek a jogkivonatát ellopták. A közzétevők letiltásával az ügyfél használhatatlanná válik, amíg egy másik közzétevőt használó új jogkivonatot nem kap.

Event Hubs-felhasználók hitelesítése SAS használatával

Az Event Hubs-előállítók által létrehozott adatokból felhasznált háttéralkalmazások hitelesítéséhez az Event Hubs-jogkivonat hitelesítéséhez az ügyfeleknek rendelkezniük kell a felügyeleti jogosultságokkal vagy a figyelési jogosultságokkal az Event Hubs-névtérhez, eseményközpont-példányhoz vagy -témakörhöz rendelve. Az adatok az Event Hubsból fogyasztói csoportok használatával lesznek felhasználva. Bár az SAS-szabályzat részletes hatókört biztosít, ez a hatókör csak az entitás szintjén van meghatározva, a fogyasztói szinten nem. Ez azt jelenti, hogy a névtér szintjén vagy az eseményközpont-példány vagy -témakör szintjén meghatározott jogosultságok az entitás fogyasztói csoportjaira lesznek alkalmazva.

A helyi/SAS-kulcsos hitelesítés letiltása

Bizonyos szervezeti biztonsági követelmények esetén előfordulhat, hogy teljesen le kell tiltania a helyi/SAS-kulcsos hitelesítést, és a Azure Active Directory (Azure AD) alapú hitelesítésre kell hagyatkoznia, amely a Azure Event Hubs való kapcsolódás ajánlott módja. Az Event Hubs-névtér szintjén letilthatja a helyi/SAS-kulcsos hitelesítést Azure Portal vagy az Azure Resource Manager sablon használatával.

A helyi/SAS-kulcsos hitelesítés letiltása a portálon keresztül

Egy adott Event Hubs-névtér helyi/SAS-kulcsos hitelesítését a Azure Portal letilthatja.

Az alábbi képen látható módon a névtér áttekintési szakaszában kattintson a helyi hitelesítésre.

Ezután válassza a Letiltva lehetőséget, és kattintson az OK gombra az alább látható módon.

A helyi/SAS-kulcsos hitelesítés letiltása sablon használatával

Letilthatja egy adott Event Hubs-névtér helyi hitelesítését, ha a tulajdonságot true az alábbi Azure Resource Manager sablonban (ARM-sablonban) látható módon állítja bedisableLocalAuth.

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

        }
      ]
    }
  ]

Következő lépések

Lásd az alábbi cikkeket:

• Engedélyezés SAS használatával
• Engedélyezés azure-beli szerepköralapú hozzáférés-vezérléssel (Azure RBAC)
• További információ az Event Hubsról

Tekintse meg a következő kapcsolódó cikkeket:

• Alkalmazásból Azure Event Hubs kéréseinek hitelesítése az Azure Active Directory használatával
• Felügyelt identitás hitelesítése Azure Active Directory az Event Hubs-erőforrások eléréséhez
• Event Hubs-erőforrásokhoz való hozzáférés engedélyezése az Azure Active Directory segítségével
• Event Hubs-erőforrásokhoz való hozzáférés engedélyezése közös hozzáférésű jogosultságkódokkal